lenexpy 3.0.1__py3-none-any.whl

lenexpy/__init__.py

@@ -0,0 +1,129 @@
+from .decoder import load as fromfile, save as tofile
+from .models.agedate import TypeAgeDate, AgeDate
+from .models.agegroup import Calculate, AgeGroup
+from .models.athelete import Athlete
+from .models.base import LenexBaseXmlModel
+from .models.club import TypeClub, Club
+from .models.constructor import Constructor
+from .models.contact import Contact
+from .models.course import Course
+from .models.currency import Currency
+from .models.entry import Status, Entry
+from .models.event import Round, TypeEvent, Event
+from .models.fee import TypeFee, Fee
+from .models.gender import Gender
+from .models.handicap import HandicapClass, Handicap
+from .models.heat import Final, StatusHeat, Heat
+from .models.judge import Role as JudgeRole, Judge
+from .models.lenex import Lenex
+from .models.meet import EntryType, Meet
+from .models.meetinfoentry import MeetInfoEntry
+from .models.meetinforecord import Role as MeetInfoRecordRole, MeetInfoRecord
+from .models.nation import Nation
+from .models.official import Official
+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
+from .models.relayposition import (
+    StatusRelayPosition as RelayPositionStatus,
+    RelayPosition,
+)
+from .models.relayrecord import (
+    StatusRelayPosition as RelayRecordStatus,
+    RelayRecord,
+)
+from .models.result import StatusResult, Result
+from .models.session import Session
+from .models.split import Split
+from .models.stroke import Stroke
+from .models.swimstyle import Technique, SwimStyle
+from .models.swimtime import SwimTimeAttr, SwimTime
+from .models.timestandard import TimeStandard
+from .models.timestandardlist import TypeTimeStandardList, TimeStandardList
+from .models.timestandardref import TimeStandardRef
+from .models.timing import Timing
+from .models_st.athelete import Athlete as AthleteST
+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__ = [
+    "fromfile",
+    "tofile",
+    "TypeAgeDate",
+    "AgeDate",
+    "Calculate",
+    "AgeGroup",
+    "Athlete",
+    "LenexBaseXmlModel",
+    "TypeClub",
+    "Club",
+    "Constructor",
+    "Contact",
+    "Course",
+    "Currency",
+    "Status",
+    "Entry",
+    "Round",
+    "TypeEvent",
+    "Event",
+    "TypeFee",
+    "Fee",
+    "Gender",
+    "HandicapClass",
+    "Handicap",
+    "Final",
+    "StatusHeat",
+    "Heat",
+    "JudgeRole",
+    "Judge",
+    "Lenex",
+    "EntryType",
+    "Meet",
+    "MeetInfoEntry",
+    "MeetInfoRecordRole",
+    "MeetInfoRecord",
+    "Nation",
+    "Official",
+    "PointTable",
+    "TypePool",
+    "Pool",
+    "Conversion",
+    "Qualify",
+    "Ranking",
+    "ReactionTime",
+    "Record",
+    "RecordList",
+    "RelayMeet",
+    "RelayPositionStatus",
+    "RelayPosition",
+    "RelayRecordStatus",
+    "RelayRecord",
+    "StatusResult",
+    "Result",
+    "Session",
+    "Split",
+    "Stroke",
+    "Technique",
+    "SwimStyle",
+    "SwimTimeAttr",
+    "SwimTime",
+    "TimeStandard",
+    "TypeTimeStandardList",
+    "TimeStandardList",
+    "TimeStandardRef",
+    "Timing",
+    "AthleteST",
+    "StatusST",
+    "EntryST",
+    "FinalST",
+    "StatusHeatST",
+    "HeatST",
+    "StatusResultST",
+    "ResultST",
+]

lenexpy/decoder/__init__.py

@@ -0,0 +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

lenexpy/decoder/decoder.py

@@ -0,0 +1,15 @@
+
+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"):
+        return decode_lef(filename)
+    if suffix == ".lxf":
+        return decode_lxf(filename)
+    raise TypeError("The file type must be .lxf, .lef, .xml")

lenexpy/decoder/encoder.py

@@ -0,0 +1,14 @@
+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"):
+        return encode_lef(lenex, filename)
+    if suffix == ".lxf":
+        return encode_lxf(lenex, filename)
+    raise TypeError("The file type must be .lxf, .lef, .xml")

lenexpy/decoder/lef_decoder.py

@@ -0,0 +1,10 @@
+from lenexpy.models.lenex import Lenex
+
+
+def decode_lef(filename: str) -> Lenex:
+    with open(filename, "rb") as file:
+        return decode_lef_bytes(file.read())
+
+
+def decode_lef_bytes(data: bytes) -> Lenex:
+    return Lenex.from_xml(data)

lenexpy/decoder/lef_encoder.py

@@ -0,0 +1,19 @@
+from lenexpy.models.lenex import Lenex
+
+ENCODING = 'utf-8'
+
+
+def encode_lef_bytes(lenex: Lenex) -> bytes:
+    xml_value = lenex.to_xml(encoding=ENCODING, xml_declaration=True)
+    if isinstance(xml_value, str):
+        return xml_value.encode(ENCODING)
+    return xml_value
+
+
+def encode_lef(lenex: Lenex, filename: str):
+    if not filename.endswith(('.lef', '.xml')):
+        raise TypeError('The file type must be .lef, .xml')
+
+    xml_string = encode_lef_bytes(lenex)
+    with open(filename, "wb") as f:
+        f.write(xml_string)

lenexpy/decoder/lxf_decoder.py

@@ -0,0 +1,21 @@
+from io import BytesIO
+from zipfile import ZipFile
+
+from lenexpy.decoder.lef_decoder import decode_lef_bytes
+from lenexpy.models.lenex import Lenex
+
+
+def decode_lxf(filename: str) -> Lenex:
+    with open(filename, "rb") as file:
+        return decode_lxf_bytes(file.read())
+
+
+def decode_lxf_bytes(data: bytes) -> Lenex:
+    with ZipFile(BytesIO(data)) as zp:
+        if not zp.filelist:
+            raise TypeError("Incorrect lenex file")
+
+        lef_members = [m for m in zp.filelist if m.filename.lower().endswith(".lef")]
+        member = lef_members[0] if lef_members else zp.filelist[0]
+        with zp.open(member) as file:
+            return decode_lef_bytes(file.read())

lenexpy/decoder/lxf_encoder.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+from io import BytesIO
+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')
+
+    lxf_bytes = encode_lxf_bytes(lenex, Path(filename).name)
+    with open(filename, "wb") as f:
+        f.write(lxf_bytes)
+
+
+def encode_lxf_bytes(lenex: Lenex, filename: str = "lenex.lxf") -> bytes:
+    fn = Path(filename).name[:-4] + ".lef"
+    xml_bytes = encode_lef_bytes(lenex)
+    buffer = BytesIO()
+    with ZipFile(buffer, "w", compression=ZIP_DEFLATED) as zf:
+        zf.writestr(fn, xml_bytes)
+    return buffer.getvalue()

lenexpy/models/agedate.py

@@ -0,0 +1,20 @@
+from datetime import date
+
+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"
+
+
+# TODO: confirm root tag for AgeDate.
+class AgeDate(LenexBaseXmlModel, tag="AGEDATE"):
+    type: TypeAgeDate = attr(name="type")
+    value: date = attr(name="value")

lenexpy/models/agegroup.py

@@ -0,0 +1,32 @@
+from lenexpy.strenum import StrEnum
+from typing import List, Optional
+from pydantic_xml import attr, wrapped, element
+
+from .base import LenexBaseXmlModel
+
+from .ranking import Ranking
+from .gender import Gender
+
+
+class Calculate(StrEnum):
+    TOTAL: str = 'TOTAL'
+    SINGLE: str = 'SINGLE'
+
+
+# TODO: confirm root tag for AgeGroup.
+class AgeGroup(LenexBaseXmlModel, tag="AGEGROUP"):
+    id: Optional[int] = attr(name="agegroupid", default=None)
+    agemax: int = attr(name="agemax")
+    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)
+    levelmax: Optional[int] = attr(name="levelmax", default=None)
+    levelmin: Optional[int] = attr(name="levelmin", default=None)
+    levels: Optional[str] = attr(name="levels", default=None)
+    name: Optional[str] = attr(name="name", default=None)
+    rankings: List[Ranking] = wrapped(
+        "RANKINGS",
+        element(tag="RANKING"),
+        default_factory=list,
+    )

lenexpy/models/athelete.py

@@ -0,0 +1,63 @@
+from datetime import date
+from typing import List, Optional
+
+from pydantic import model_validator
+from pydantic_xml import attr, element, wrapped
+
+from lenexpy.strenum import StrEnum
+
+from .base import LenexBaseXmlModel
+from .entry import Entry
+from .gender import Gender
+from .handicap import Handicap
+from .nation import Nation
+from .result import Result
+
+
+class AthleteStatus(StrEnum):
+    EXHIBITION = "EXHIBITION"
+    FOREIGNER = "FOREIGNER"
+    ROOKIE = "ROOKIE"
+    STARTSUISSE = "SUI.STARTSUISSE"
+
+
+# required_params = {'birthday', 'gender', 'firstname', 'lastname'}/
+
+
+# TODO: confirm root tag for Athlete.
+class Athlete(LenexBaseXmlModel, tag="ATHLETE"):
+    athleteid: int = attr(name="athleteid")
+    birthdate: date = attr(name="birthdate")
+    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_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)
+    license_dbs: Optional[str] = attr(name="license_dbs", default=None)
+    license_dsv: Optional[str] = attr(name="license_dsv", default=None)
+    license_ipc: Optional[int] = attr(name="license_ipc", default=None)
+    nameprefix: Optional[str] = attr(name="nameprefix", default=None)
+    nation: Optional[Nation] = attr(name="nation", default=None)
+    passport: Optional[str] = attr(name="passport", default=None)
+    results: List[Result] = wrapped(
+        "RESULTS",
+        element(tag="RESULT"),
+        default_factory=list,
+    )
+    status: Optional[AthleteStatus] = attr(name="status", default=None)
+    swrid: Optional[int] = attr(name="swrid", default=None)
+
+    @model_validator(mode="before")
+    @classmethod
+    def _map_id(cls, data):
+        if isinstance(data, dict) and "id" in data and "athleteid" not in data:
+            data["athleteid"] = data.pop("id")
+        return data

lenexpy/models/bank.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+from pydantic_xml import attr
+
+from .base import LenexBaseXmlModel
+
+
+class Bank(LenexBaseXmlModel, tag="BANK"):
+    accountholder: str = attr(name="accountholder")
+    bic: Optional[str] = attr(name="bic", default=None)
+    iban: str = attr(name="iban")
+    name: Optional[str] = attr(name="name", default=None)
+    note: Optional[str] = attr(name="note", default=None)

lenexpy/models/base.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from pydantic import ConfigDict, model_validator
+from pydantic_xml import BaseXmlModel
+
+
+class LenexBaseXmlModel(BaseXmlModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @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

lenexpy/models/club.py

@@ -0,0 +1,48 @@
+from lenexpy.strenum import StrEnum
+from typing import List, Optional
+from pydantic_xml import attr, element, wrapped
+
+from .base import LenexBaseXmlModel
+
+from .nation import Nation
+from .official import Official
+from .relaymeet import RelayMeet
+from .athelete import Athlete
+from .contact import Contact
+
+
+class TypeClub(StrEnum):
+    CLUB = "CLUB",
+    NATIONALTEAM = "NATIONALTEAM",
+    REGIONALTEAM = "REGIONALTEAM",
+    UNATTACHED = "UNATTACHED"
+
+
+# TODO: confirm root tag for Club.
+class Club(LenexBaseXmlModel, tag="CLUB"):
+    contact: Optional[Contact] = element(tag="CONTACT", default=None)
+    code: Optional[str] = attr(name="code", default=None)
+    athletes: List[Athlete] = wrapped(
+        "ATHLETES",
+        element(tag="ATHLETE"),
+        default_factory=list,
+    )
+    name: str = attr(name="name")
+    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)
+    officials: List[Official] = wrapped(
+        "OFFICIALS",
+        element(tag="OFFICIAL"),
+        default_factory=list,
+    )
+    region: Optional[str] = attr(name="region", default=None)
+    relays: List[RelayMeet] = wrapped(
+        "RELAYS",
+        element(tag="RELAY"),
+        default_factory=list,
+    )
+    shortname: Optional[str] = attr(name="shortname", default=None)
+    shortname_en: Optional[str] = attr(name="shortname.en", default=None)
+    swrid: Optional[str] = attr(name="swrid", default=None)
+    type: Optional[TypeClub] = attr(name="type", default=None)

lenexpy/models/common.py

@@ -0,0 +1,34 @@
+from lenexpy.strenum import StrEnum
+
+
+class StartMethod(StrEnum):
+    ONE_START = "1"
+    TWO_STARTS = "2"
+
+
+class TouchpadMode(StrEnum):
+    ONESIDE = "ONESIDE"
+    BOTHSIDE = "BOTHSIDE"
+
+
+class StatusMeet(StrEnum):
+    ENTRIES = "ENTRIES"
+    SEEDED = "SEEDED"
+    RUNNING = "RUNNING"
+    OFFICIAL = "OFFICIAL"
+
+
+class StatusSession(StrEnum):
+    ENTRIES = "ENTRIES"
+    SEEDED = "SEEDED"
+    RUNNING = "RUNNING"
+    UNOFFICIAL = "UNOFFICIAL"
+    OFFICIAL = "OFFICIAL"
+
+
+class StatusEvent(StrEnum):
+    ENTRIES = "ENTRIES"
+    SEEDED = "SEEDED"
+    RUNNING = "RUNNING"
+    UNOFFICIAL = "UNOFFICIAL"
+    OFFICIAL = "OFFICIAL"

lenexpy/models/constructor.py

@@ -0,0 +1,14 @@
+from typing import Optional
+
+from pydantic_xml import attr, element
+
+from .base import LenexBaseXmlModel
+from .contact import Contact
+
+
+# TODO: confirm root tag for Constructor.
+class Constructor(LenexBaseXmlModel, tag="CONSTRUCTOR"):
+    contact: Contact = element(tag="CONTACT")
+    name: str = attr(name="name")
+    registration: Optional[str] = attr(name="registration", default=None)
+    version: str = attr(name="version")

lenexpy/models/contact.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from pydantic_xml import attr
+
+from .base import LenexBaseXmlModel
+
+
+# TODO: confirm root tag for Contact.
+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")
+    fax: Optional[str] = attr(name="fax", default=None)
+    internet: Optional[str] = attr(name="internet", default=None)
+    name: Optional[str] = attr(name="name", default=None)
+    mobile: Optional[str] = attr(name="mobile", default=None)
+    phone: Optional[str] = attr(name="phone", default=None)
+    state: Optional[str] = attr(name="state", default=None)
+    street: Optional[str] = attr(name="street", default=None)
+    street2: Optional[str] = attr(name="street2", default=None)
+    zip: Optional[str] = attr(name="zip", default=None)

lenexpy/models/course.py

@@ -0,0 +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"

lenexpy/models/currency.py

@@ -0,0 +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"

lenexpy/models/entry.py

@@ -0,0 +1,49 @@
+from datetime import time
+from typing import List, Optional, Union
+
+from lenexpy.strenum import StrEnum
+from pydantic import field_validator
+from pydantic_xml import attr, element, wrapped
+
+from .base import LenexBaseXmlModel
+
+from .course import Course
+from .handicap import HandicapClass
+from .meetinfoentry import MeetInfoEntry
+from .relayposition import RelayPosition
+from .swimtime import SwimTime
+
+
+class Status(StrEnum):
+    EXH = "EXH"
+    RJC = "RJC"
+    SICK = "SICK"
+    WDR = "WDR"
+
+
+# TODO: confirm root tag for Entry.
+class Entry(LenexBaseXmlModel, tag="ENTRY"):
+    agegroupid: Optional[int] = attr(name="agegroupid", default=None)
+    entrycourse: Optional[Course] = attr(name="entrycourse", default=None)
+    entrydistance: Optional[int] = attr(name="entrydistance", default=None)
+    entrytime: Optional[SwimTime] = attr(name="entrytime", default=None)
+    eventid: int = attr(name="eventid")
+    handicap: Optional[HandicapClass] = attr(name="handicap", default=None)
+    heatid: Optional[int] = attr(name="heatid", default=None)
+    lane: Optional[int] = attr(name="lane", default=None)
+    meetinfo: Optional[MeetInfoEntry] = element(tag="MEETINFO", default=None)
+    relay_positions: List[RelayPosition] = wrapped(
+        "RELAYPOSITIONS",
+        element(tag="RELAYPOSITION"),
+        default_factory=list,
+    )
+    status: Optional[Status] = attr(name="status", default=None)
+
+    @field_validator("entrytime", mode="before")
+    @classmethod
+    def _parse_entrytime(cls, value):
+        if value is None or isinstance(value, SwimTime):
+            return value
+        if isinstance(value, (str, time)):
+            return SwimTime._parse(value)
+        return value