updated db

.github/copilot-instructions.md

@@ -0,0 +1,139 @@
+# AlpineBits Python Server - AI Agent Instructions
+
+## Project Overview
+
+This is an **AlpineBits 2024-10 server** that bridges booking requests from Wix landing pages to hotel partners. It's a dual-purpose system:
+
+1. **FastAPI webhook receiver** - accepts booking forms from wix.com landing pages via `/api/webhook/wix-form`
+2. **AlpineBits OTA server** - exposes hotel reservation data at `/api/alpinebits/server-2024-10` using OpenTravel Alliance XML protocol
+
+Data flows: Wix form → Database → AlpineBits XML → Hotel systems (pull or push)
+
+## Architecture Patterns
+
+### XML Generation with xsdata
+
+- **Never manually construct XML strings**. Use xsdata-generated Pydantic dataclasses from `src/alpine_bits_python/generated/alpinebits.py`
+- Parse XML: `XmlParser().from_string(xml_string, OtaPingRq)`
+- Serialize XML: `XmlSerializer(config=SerializerConfig(...)).render(ota_object)`
+- Factory pattern: Use classes in `alpine_bits_helpers.py` (e.g., `CustomerFactory`, `GuestCountsFactory`) to build complex OTA objects from DB models
+- Example: `create_res_retrieve_response()` builds OTA_ResRetrieveRS from `(Reservation, Customer)` tuples
+- **Regenerating XML classes**: Run `xsdata` on `AlpineBits-HotelData-2024-10/files/schema-xsd/alpinebits.xsd` to regenerate `generated/alpinebits.py` (only if XSD spec changes)
+
+### Configuration System
+
+- Config loaded from YAML with secret injection via `!secret` tags (see `config_loader.py`)
+- Default config location: `config/config.yaml` + `config/secrets.yaml`
+- Override via `ALPINEBITS_CONFIG_DIR` environment variable
+- Multi-hotel support: Each hotel in `alpine_bits_auth` array gets own credentials and optional `push_endpoint`
+
+### Database Layer
+
+- **Async-only SQLAlchemy** with `AsyncSession` (see `db.py`)
+- Three core tables: `Customer`, `Reservation`, `AckedRequest` (tracks which clients acknowledged which reservations)
+- DB URL configurable: SQLite for dev (`sqlite+aiosqlite:///alpinebits.db`), PostgreSQL for prod
+- Database auto-created on startup in `api.py:create_app()`
+
+### Event-Driven Push System
+
+- `EventDispatcher` in `api.py` enables hotel-specific listeners: `event_dispatcher.register_hotel_listener("reservation:created", hotel_code, push_listener)`
+- Push listener sends OTA_HotelResNotif XML to hotel's configured `push_endpoint.url` with Bearer token auth
+- Push requests logged to `logs/push_requests/` with timestamp and unique ID
+- **Note**: Push endpoint support is currently dormant - configured but not actively used by partners
+
+### AlpineBits Action Pattern
+
+- Each OTA action is a class inheriting `AlpineBitsActionHandler` (see `alpinebits_server.py`)
+- Actions: `PingAction`, `ReadAction`, `NotifReportAction`, `PushAction`
+- Request flow: Parse XML → Call `handle()` → Return `AlpineBitsActionResult` with XML response + HTTP status
+- `AlpineBitsActionName` enum maps capability names to request names (e.g., `OTA_READ` → `"OTA_Read:GuestRequests"`)
+- Server supports multiple AlpineBits versions (2024-10, 2022-10) when actions are identical across versions
+
+### Acknowledgment System
+
+- `AckedRequest` table tracks which clients acknowledged which reservations via `OTA_NotifReport:GuestRequests`
+- Read requests filter out acknowledged reservations for clients with `client_id`
+- Prevents duplicate reservation sends: once acknowledged, data won't appear in subsequent reads for that client
+
+## Critical Workflows
+
+### Running Locally
+
+```bash
+uv sync                                    # Install dependencies (uses uv, not pip!)
+uv run python -m alpine_bits_python.run_api  # Start server on port 8080, clears DB on startup
+```
+
+### Testing
+
+```bash
+uv run pytest                              # Run all tests
+uv run pytest tests/test_alpine_bits_server_read.py  # Specific test file
+```
+
+- Tests use in-memory SQLite via `test_db_engine` fixture (see `tests/test_alpine_bits_server_read.py`)
+- Test data fixtures in `tests/test_data/` directory
+
+### Building for Deployment
+
+```bash
+uv sync
+docker build . -t gitea.linter-home.com/jonas/asa_api:master
+```
+
+- Multi-stage Dockerfile: builder stage installs deps with uv, production stage copies `.venv`
+- Runs as non-root user (UID 1000) for security
+- Requires `ALPINEBITS_CONFIG_DIR=/config` volume mount for config files
+- **Deployment**: Docker build pipeline exists and works; can also build manually on target system
+
+## Project-Specific Conventions
+
+### Naming Patterns
+
+- OTA message types use full AlpineBits names: `OtaReadRq`, `OtaResRetrieveRs`, `OtaHotelResNotifRq`
+- Factory classes suffix with `Factory`: `CustomerFactory`, `HotelReservationIdFactory`
+- DB models in `db.py`, validation schemas in `schemas.py`, OTA helpers in `alpine_bits_helpers.py`
+
+### Data Validation Flow
+
+1. **API Layer** → Pydantic schemas (`schemas.py`) validate incoming data
+2. **DB Layer** → SQLAlchemy models (`db.py`) persist validated data
+3. **XML Layer** → xsdata classes (`generated/alpinebits.py`) + factories (`alpine_bits_helpers.py`) generate OTA XML
+
+This separation prevents mixing concerns (validation ≠ persistence ≠ XML generation).
+
+### Unique ID Generation
+
+- Reservation IDs: 35-char max, format `{hotel_code}_{uuid4}_{timestamp}`
+- Generated via `generate_unique_id()` in `auth.py`
+
+### Rate Limiting
+
+- Uses `slowapi` with Redis backend
+- Three tiers: `DEFAULT_RATE_LIMIT` (100/hour), `WEBHOOK_RATE_LIMIT` (300/hour), `BURST_RATE_LIMIT` (10/minute)
+- Applied via decorators: `@limiter.limit(DEFAULT_RATE_LIMIT)`
+
+## Common Pitfalls
+
+1. **Don't use synchronous SQLAlchemy calls** - Always `await session.execute()`, never `session.query()`
+2. **Don't hardcode XML namespaces** - Let xsdata handle them via generated classes
+3. **Don't skip config validation** - Voluptuous schemas in `config_loader.py` catch config errors early
+4. **Auth is per-hotel** - HTTP Basic Auth credentials from `alpine_bits_auth` config array
+5. **AlpineBits version matters** - Server implements 2024-10 spec (see `AlpineBits-HotelData-2024-10/` directory)
+
+## Key Files Reference
+
+- `api.py` - FastAPI app, all endpoints, event dispatcher
+- `alpinebits_server.py` - AlpineBits action handlers (Ping, Read, NotifReport)
+- `alpine_bits_helpers.py` - Factory classes for building OTA XML from DB models
+- `config_loader.py` - YAML config loading with secret injection
+- `db.py` - SQLAlchemy async models (Customer, Reservation, AckedRequest)
+- `schemas.py` - Pydantic validation schemas
+- `generated/alpinebits.py` - xsdata-generated OTA XML classes (DO NOT EDIT - regenerate from XSD)
+
+## Testing Strategy
+
+- Fixtures create isolated in-memory databases per test
+- Use `test_config()` fixture for test configuration
+- XML serialization/parsing tested via xsdata round-trips
+- Push endpoint mocking via httpx in tests

logs/push_requests/alpinebits_push_12345_8e68dab6-7c2e-4c67-9471-b8cbfb7b3fcb_20251007_171338.xml

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<OTA_HotelResNotifRQ xmlns="http://www.opentravel.org/OTA/2003/05" Version="7.000">
+  <HotelReservations>
+    <HotelReservation CreateDateTime="2025-10-07T15:13:38.831800+00:00" ResStatus="Requested" RoomStayReservation="true">
+      <UniqueID Type="14" ID="8e68dab6-7c2e-4c67-9471-b8cbfb7b"/>
+      <RoomStays>
+        <RoomStay>
+          <GuestCounts>
+            <GuestCount Count="13"/>
+          </GuestCounts>
+          <TimeSpan Start="2025-10-25" End="2025-10-26"/>
+        </RoomStay>
+      </RoomStays>
+      <ResGuests>
+        <ResGuest>
+          <Profiles>
+            <ProfileInfo>
+              <Profile>
+                <Customer Language="de">
+                  <PersonName>
+                    <NamePrefix>Frau</NamePrefix>
+                    <GivenName>Christine</GivenName>
+                    <Surname>Niederkofler</Surname>
+                  </PersonName>
+                  <Telephone PhoneTechType="5" PhoneNumber="+4953346312"/>
+                  <Email Remark="newsletter:yes">info@ledermode.at</Email>
+                </Customer>
+              </Profile>
+            </ProfileInfo>
+          </Profiles>
+        </ResGuest>
+      </ResGuests>
+      <ResGlobalInfo>
+        <Comments>
+          <Comment Name="additional info">
+            <Text>Angebot/Offerta: Törggelewochen - Herbstliche Genüsse &amp; Südtiroler Tradition</Text>
+          </Comment>
+          <Comment Name="customer comment">
+            <Text>Hallo. Wir würden gerne mit unseren Mitarbeitern vom 25.10 - 26.10.25 nach Südtirol fahren.
+Geplant wäre am Samstagabend Törggelen und am Sonntag nach dem Frühstück mit der Gondel zur Seiser Alm zu fahren.
+Wir sind ca. 13 Personen (es können gerne auch 3-Bettzimmer dabei sein falls vorhanden. Sonst DZ und wir benötigen 1 EZ).
+Bitte um ein Angebot für Törggelen, Übernachtung und Frühstück. Vielen lieben Dank! Christine Niederkofler</Text>
+          </Comment>
+        </Comments>
+        <HotelReservationIDs>
+          <HotelReservationID ResID_Type="13" ResID_Value="Cj0KCQjw3OjGBhDYARIsADd-uX65gXKdbOti_3OOA50T-B9Uj-zsOzXJ7g2-8Tz_" ResID_Source="google" ResID_SourceContext="99tales"/>
+        </HotelReservationIDs>
+        <Profiles>
+          <ProfileInfo>
+            <Profile ProfileType="4">
+              <CompanyInfo>
+                <CompanyName Code="who knows?" CodeContext="who knows?">99tales GmbH</CompanyName>
+              </CompanyInfo>
+            </Profile>
+          </ProfileInfo>
+        </Profiles>
+        <BasicPropertyInfo HotelCode="12345" HotelName="Frangart Inn"/>
+      </ResGlobalInfo>
+    </HotelReservation>
+  </HotelReservations>
+</OTA_HotelResNotifRQ>

logs/push_requests/alpinebits_push_12345_c52702c9-55b9-44e1-b158-ec9544c73cc7_20251007_155426.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<OTA_HotelResNotifRQ xmlns="http://www.opentravel.org/OTA/2003/05" Version="7.000">
+  <HotelReservations/>
+</OTA_HotelResNotifRQ>

logs/push_requests/alpinebits_push_12345_c52702c9-55b9-44e1-b158-ec9544c73cc7_20251007_160537.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<OTA_HotelResNotifRQ xmlns="http://www.opentravel.org/OTA/2003/05" Version="7.000">
+  <HotelReservations>
+    <HotelReservation CreateDateTime="2025-10-07T14:05:37.563674+00:00" ResStatus="Requested" RoomStayReservation="true">
+      <UniqueID Type="14" ID="c52702c9-55b9-44e1-b158-ec9544c7"/>
+      <RoomStays>
+        <RoomStay>
+          <GuestCounts>
+            <GuestCount Count="3"/>
+            <GuestCount Count="1" Age="12"/>
+          </GuestCounts>
+          <TimeSpan Start="2026-01-02" End="2026-01-07"/>
+        </RoomStay>
+      </RoomStays>
+      <ResGuests>
+        <ResGuest>
+          <Profiles>
+            <ProfileInfo>
+              <Profile>
+                <Customer Language="it">
+                  <PersonName>
+                    <NamePrefix>Frau</NamePrefix>
+                    <GivenName>Genesia</GivenName>
+                    <Surname>Supino</Surname>
+                  </PersonName>
+                  <Telephone PhoneTechType="5" PhoneNumber="+393406259979"/>
+                  <Email Remark="newsletter:yes">supinogenesia@gmail.com</Email>
+                </Customer>
+              </Profile>
+            </ProfileInfo>
+          </Profiles>
+        </ResGuest>
+      </ResGuests>
+      <ResGlobalInfo>
+        <HotelReservationIDs>
+          <HotelReservationID ResID_Type="13" ResID_Value="IwZXh0bgNhZW0BMABhZGlkAassWPh1b8QBHoRc2S24gMktdNKiPwEvGYMK3rB-mn" ResID_Source="Facebook_Mobile_Feed" ResID_SourceContext="99tales"/>
+        </HotelReservationIDs>
+        <Profiles>
+          <ProfileInfo>
+            <Profile ProfileType="4">
+              <CompanyInfo>
+                <CompanyName Code="who knows?" CodeContext="who knows?">99tales GmbH</CompanyName>
+              </CompanyInfo>
+            </Profile>
+          </ProfileInfo>
+        </Profiles>
+        <BasicPropertyInfo HotelCode="12345" HotelName="Bemelmans Post"/>
+      </ResGlobalInfo>
+    </HotelReservation>
+  </HotelReservations>
+</OTA_HotelResNotifRQ>

logs/push_requests/alpinebits_push_12345_c52702c9-55b9-44e1-b158-ec9544c73cc7_20251007_162404.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<OTA_HotelResNotifRQ xmlns="http://www.opentravel.org/OTA/2003/05" Version="7.000">
+  <HotelReservations>
+    <HotelReservation CreateDateTime="2025-10-07T14:24:04.943026+00:00" ResStatus="Requested" RoomStayReservation="true">
+      <UniqueID Type="14" ID="c52702c9-55b9-44e1-b158-ec9544c7"/>
+      <RoomStays>
+        <RoomStay>
+          <GuestCounts>
+            <GuestCount Count="3"/>
+            <GuestCount Count="1" Age="12"/>
+          </GuestCounts>
+          <TimeSpan Start="2026-01-02" End="2026-01-07"/>
+        </RoomStay>
+      </RoomStays>
+      <ResGuests>
+        <ResGuest>
+          <Profiles>
+            <ProfileInfo>
+              <Profile>
+                <Customer Language="it">
+                  <PersonName>
+                    <NamePrefix>Frau</NamePrefix>
+                    <GivenName>Genesia</GivenName>
+                    <Surname>Supino</Surname>
+                  </PersonName>
+                  <Telephone PhoneTechType="5" PhoneNumber="+393406259979"/>
+                  <Email Remark="newsletter:yes">supinogenesia@gmail.com</Email>
+                </Customer>
+              </Profile>
+            </ProfileInfo>
+          </Profiles>
+        </ResGuest>
+      </ResGuests>
+      <ResGlobalInfo>
+        <HotelReservationIDs>
+          <HotelReservationID ResID_Type="13" ResID_Value="IwZXh0bgNhZW0BMABhZGlkAassWPh1b8QBHoRc2S24gMktdNKiPwEvGYMK3rB-mn" ResID_Source="Facebook_Mobile_Feed" ResID_SourceContext="99tales"/>
+        </HotelReservationIDs>
+        <Profiles>
+          <ProfileInfo>
+            <Profile ProfileType="4">
+              <CompanyInfo>
+                <CompanyName Code="who knows?" CodeContext="who knows?">99tales GmbH</CompanyName>
+              </CompanyInfo>
+            </Profile>
+          </ProfileInfo>
+        </Profiles>
+        <BasicPropertyInfo HotelCode="12345" HotelName="Bemelmans Post"/>
+      </ResGlobalInfo>
+    </HotelReservation>
+  </HotelReservations>
+</OTA_HotelResNotifRQ>

logs/push_requests/alpinebits_push_12345_c52702c9-55b9-44e1-b158-ec9544c73cc7_20251007_163252.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<OTA_HotelResNotifRQ xmlns="http://www.opentravel.org/OTA/2003/05" Version="7.000">
+  <HotelReservations>
+    <HotelReservation CreateDateTime="2025-10-07T14:32:52.523968+00:00" ResStatus="Requested" RoomStayReservation="true">
+      <UniqueID Type="14" ID="c52702c9-55b9-44e1-b158-ec9544c7"/>
+      <RoomStays>
+        <RoomStay>
+          <GuestCounts>
+            <GuestCount Count="3"/>
+            <GuestCount Count="1" Age="12"/>
+          </GuestCounts>
+          <TimeSpan Start="2026-01-02" End="2026-01-07"/>
+        </RoomStay>
+      </RoomStays>
+      <ResGuests>
+        <ResGuest>
+          <Profiles>
+            <ProfileInfo>
+              <Profile>
+                <Customer Language="it">
+                  <PersonName>
+                    <NamePrefix>Frau</NamePrefix>
+                    <GivenName>Genesia</GivenName>
+                    <Surname>Supino</Surname>
+                  </PersonName>
+                  <Telephone PhoneTechType="5" PhoneNumber="+393406259979"/>
+                  <Email Remark="newsletter:yes">supinogenesia@gmail.com</Email>
+                </Customer>
+              </Profile>
+            </ProfileInfo>
+          </Profiles>
+        </ResGuest>
+      </ResGuests>
+      <ResGlobalInfo>
+        <HotelReservationIDs>
+          <HotelReservationID ResID_Type="13" ResID_Value="IwZXh0bgNhZW0BMABhZGlkAassWPh1b8QBHoRc2S24gMktdNKiPwEvGYMK3rB-mn" ResID_Source="Facebook_Mobile_Feed" ResID_SourceContext="99tales"/>
+        </HotelReservationIDs>
+        <Profiles>
+          <ProfileInfo>
+            <Profile ProfileType="4">
+              <CompanyInfo>
+                <CompanyName Code="who knows?" CodeContext="who knows?">99tales GmbH</CompanyName>
+              </CompanyInfo>
+            </Profile>
+          </ProfileInfo>
+        </Profiles>
+        <BasicPropertyInfo HotelCode="12345" HotelName="Bemelmans Post"/>
+      </ResGlobalInfo>
+    </HotelReservation>
+  </HotelReservations>
+</OTA_HotelResNotifRQ>

logs/push_requests/alpinebits_push_12345_c52702c9-55b9-44e1-b158-ec9544c73cc7_20251007_171225.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<OTA_HotelResNotifRQ xmlns="http://www.opentravel.org/OTA/2003/05" Version="7.000">
+  <HotelReservations>
+    <HotelReservation CreateDateTime="2025-10-07T15:12:25.274095+00:00" ResStatus="Requested" RoomStayReservation="true">
+      <UniqueID Type="14" ID="c52702c9-55b9-44e1-b158-ec9544c7"/>
+      <RoomStays>
+        <RoomStay>
+          <GuestCounts>
+            <GuestCount Count="3"/>
+            <GuestCount Count="1" Age="12"/>
+          </GuestCounts>
+          <TimeSpan Start="2026-01-02" End="2026-01-07"/>
+        </RoomStay>
+      </RoomStays>
+      <ResGuests>
+        <ResGuest>
+          <Profiles>
+            <ProfileInfo>
+              <Profile>
+                <Customer Language="it">
+                  <PersonName>
+                    <NamePrefix>Frau</NamePrefix>
+                    <GivenName>Genesia</GivenName>
+                    <Surname>Supino</Surname>
+                  </PersonName>
+                  <Telephone PhoneTechType="5" PhoneNumber="+393406259979"/>
+                  <Email Remark="newsletter:yes">supinogenesia@gmail.com</Email>
+                </Customer>
+              </Profile>
+            </ProfileInfo>
+          </Profiles>
+        </ResGuest>
+      </ResGuests>
+      <ResGlobalInfo>
+        <HotelReservationIDs>
+          <HotelReservationID ResID_Type="13" ResID_Value="IwZXh0bgNhZW0BMABhZGlkAassWPh1b8QBHoRc2S24gMktdNKiPwEvGYMK3rB-mn" ResID_Source="Facebook_Mobile_Feed" ResID_SourceContext="99tales"/>
+        </HotelReservationIDs>
+        <Profiles>
+          <ProfileInfo>
+            <Profile ProfileType="4">
+              <CompanyInfo>
+                <CompanyName Code="who knows?" CodeContext="who knows?">99tales GmbH</CompanyName>
+              </CompanyInfo>
+            </Profile>
+          </ProfileInfo>
+        </Profiles>
+        <BasicPropertyInfo HotelCode="12345" HotelName="Bemelmans Post"/>
+      </ResGlobalInfo>
+    </HotelReservation>
+  </HotelReservations>
+</OTA_HotelResNotifRQ>

logs/wix_test_data_20251006_154435.json

@@ -259,4 +259,4 @@
     "accept": "*/*",
     "content-length": "7081"
   }
-}
+}

logs/wix_test_data_20251007_155426.json

@@ -0,0 +1,257 @@
+{
+  "timestamp": "2025-10-07T15:54:26.898008",
+  "client_ip": "127.0.0.1",
+  "headers": {
+    "host": "localhost:8080",
+    "content-type": "application/json",
+    "user-agent": "insomnia/2023.5.8",
+    "accept": "*/*",
+    "content-length": "7335"
+  },
+  "data": {
+    "data": {
+      "formName": "Contact us",
+      "submissions": [
+        {
+          "label": "Anreisedatum",
+          "value": "2026-01-02"
+        },
+        {
+          "label": "Abreisedatum",
+          "value": "2026-01-07"
+        },
+        {
+          "label": "Anzahl Erwachsene",
+          "value": "3"
+        },
+        {
+          "label": "Anzahl Kinder",
+          "value": "1"
+        },
+        {
+          "label": "Alter Kind 1",
+          "value": "12"
+        },
+        {
+          "label": "Anrede",
+          "value": "Frau"
+        },
+        {
+          "label": "Vorname",
+          "value": "Genesia "
+        },
+        {
+          "label": "Nachname",
+          "value": "Supino "
+        },
+        {
+          "label": "Email",
+          "value": "supinogenesia@gmail.com"
+        },
+        {
+          "label": "Phone",
+          "value": "+39 340 625 9979"
+        },
+        {
+          "label": "Einwilligung Marketing",
+          "value": "Selezionato"
+        },
+        {
+          "label": "utm_Source",
+          "value": "fb"
+        },
+        {
+          "label": "utm_Medium",
+          "value": "Facebook_Mobile_Feed"
+        },
+        {
+          "label": "utm_Campaign",
+          "value": "Conversions_Hotel_Bemelmans_ITA"
+        },
+        {
+          "label": "utm_Term",
+          "value": "Cold_Traffic_Conversions_Hotel_Bemelmans_ITA"
+        },
+        {
+          "label": "utm_Content",
+          "value": "Grafik_AuszeitDezember_9.12_23.12"
+        },
+        {
+          "label": "utm_term_id",
+          "value": "120238574626400196"
+        },
+        {
+          "label": "utm_content_id",
+          "value": "120238574626400196"
+        },
+        {
+          "label": "gad_source",
+          "value": ""
+        },
+        {
+          "label": "gad_campaignid",
+          "value": ""
+        },
+        {
+          "label": "gbraid",
+          "value": ""
+        },
+        {
+          "label": "gclid",
+          "value": ""
+        },
+        {
+          "label": "fbclid",
+          "value": "IwZXh0bgNhZW0BMABhZGlkAassWPh1b8QBHoRc2S24gMktdNKiPwEvGYMK3rB-mne_0IJQvQRIGH60wLvLfOm0XWP8wJ9s_aem_rbpAFMODwOh4UnF5UVxwWg"
+        },
+        {
+          "label": "hotelid",
+          "value": "12345"
+        },
+        {
+          "label": "hotelname",
+          "value": "Bemelmans Post"
+        }
+      ],
+      "field:date_picker_7e65": "2026-01-07",
+      "field:number_7cf5": "3",
+      "field:utm_source": "fb",
+      "submissionTime": "2025-10-07T05:48:41.855Z",
+      "field:alter_kind_3": "12",
+      "field:gad_source": "",
+      "field:form_field_5a7b": "Selezionato",
+      "field:gad_campaignid": "",
+      "field:utm_medium": "Facebook_Mobile_Feed",
+      "field:utm_term_id": "120238574626400196",
+      "context": {
+        "metaSiteId": "1dea821c-8168-4736-96e4-4b92e8b364cf",
+        "activationId": "2421c9cd-6565-49ba-b60f-165d3dacccba"
+      },
+      "field:email_5139": "supinogenesia@gmail.com",
+      "field:phone_4c77": "+39 340 625 9979",
+      "_context": {
+        "activation": {
+          "id": "2421c9cd-6565-49ba-b60f-165d3dacccba"
+        },
+        "configuration": {
+          "id": "a976f18c-fa86-495d-be1e-676df188eeae"
+        },
+        "app": {
+          "id": "225dd912-7dea-4738-8688-4b8c6955ffc2"
+        },
+        "action": {
+          "id": "152db4d7-5263-40c4-be2b-1c81476318b7"
+        },
+        "trigger": {
+          "key": "wix_form_app-form_submitted"
+        }
+      },
+      "field:gclid": "",
+      "formFieldMask": [
+        "field:",
+        "field:",
+        "field:angebot_auswaehlen",
+        "field:date_picker_a7c8",
+        "field:date_picker_7e65",
+        "field:",
+        "field:number_7cf5",
+        "field:anzahl_kinder",
+        "field:alter_kind_3",
+        "field:alter_kind_25",
+        "field:alter_kind_4",
+        "field:alter_kind_5",
+        "field:alter_kind_6",
+        "field:alter_kind_7",
+        "field:alter_kind_8",
+        "field:alter_kind_9",
+        "field:alter_kind_10",
+        "field:alter_kind_11",
+        "field:",
+        "field:anrede",
+        "field:first_name_abae",
+        "field:last_name_d97c",
+        "field:email_5139",
+        "field:phone_4c77",
+        "field:long_answer_3524",
+        "field:form_field_5a7b",
+        "field:",
+        "field:utm_source",
+        "field:utm_medium",
+        "field:utm_campaign",
+        "field:utm_term",
+        "field:utm_content",
+        "field:utm_term_id",
+        "field:utm_content_id",
+        "field:gad_source",
+        "field:gad_campaignid",
+        "field:gbraid",
+        "field:gclid",
+        "field:fbclid",
+        "field:hotelid",
+        "field:hotelname",
+        "field:",
+        "metaSiteId"
+      ],
+      "contact": {
+        "name": {
+          "first": "Genesia",
+          "last": "Supino"
+        },
+        "email": "supinogenesia@gmail.com",
+        "locale": "it-it",
+        "phones": [
+          {
+            "tag": "UNTAGGED",
+            "formattedPhone": "+39 340 625 9979",
+            "id": "198f04fb-5b2c-4a7b-b7ea-adc150ec4212",
+            "countryCode": "IT",
+            "e164Phone": "+393406259979",
+            "primary": true,
+            "phone": "340 625 9979"
+          }
+        ],
+        "contactId": "4d695011-36c1-4480-b225-ae9c6eef9e83",
+        "emails": [
+          {
+            "id": "e09d7bab-1f11-4b5d-b3c5-32d43c1dc584",
+            "tag": "UNTAGGED",
+            "email": "supinogenesia@gmail.com",
+            "primary": true
+          }
+        ],
+        "updatedDate": "2025-10-07T05:48:44.764Z",
+        "phone": "+393406259979",
+        "createdDate": "2025-10-07T05:48:43.567Z"
+      },
+      "submissionId": "c52702c9-55b9-44e1-b158-ec9544c73cc7",
+      "field:anzahl_kinder": "1",
+      "field:first_name_abae": "Genesia ",
+      "field:utm_content_id": "120238574626400196",
+      "field:utm_campaign": "Conversions_Hotel_Bemelmans_ITA",
+      "field:utm_term": "Cold_Traffic_Conversions_Hotel_Bemelmans_ITA",
+      "contactId": "4d695011-36c1-4480-b225-ae9c6eef9e83",
+      "field:date_picker_a7c8": "2026-01-02",
+      "field:hotelname": "Bemelmans Post",
+      "field:utm_content": "Grafik_AuszeitDezember_9.12_23.12",
+      "field:last_name_d97c": "Supino ",
+      "field:hotelid": "12345",
+      "submissionsLink": "https://manage.wix.app/forms/submissions/1dea821c-8168-4736-96e4-4b92e8b364cf/e084006b-ae83-4e4d-b2f5-074118cdb3b1?d=https%3A%2F%2Fmanage.wix.com%2Fdashboard%2F1dea821c-8168-4736-96e4-4b92e8b364cf%2Fwix-forms%2Fform%2Fe084006b-ae83-4e4d-b2f5-074118cdb3b1%2Fsubmissions&s=true",
+      "field:gbraid": "",
+      "field:fbclid": "IwZXh0bgNhZW0BMABhZGlkAassWPh1b8QBHoRc2S24gMktdNKiPwEvGYMK3rB-mne_0IJQvQRIGH60wLvLfOm0XWP8wJ9s_aem_rbpAFMODwOh4UnF5UVxwWg",
+      "submissionPdf": {
+        "fileName": "c52702c9-55b9-44e1-b158-ec9544c73cc7.pdf",
+        "downloadUrl": "https://manage.wix.com/_api/form-submission-service/v4/submissions/c52702c9-55b9-44e1-b158-ec9544c73cc7/download?accessToken=JWS.eyJraWQiOiJWLVNuLWhwZSIsImFsZyI6IkhTMjU2In0.eyJkYXRhIjoie1wibWV0YVNpdGVJZFwiOlwiMWRlYTgyMWMtODE2OC00NzM2LTk2ZTQtNGI5MmU4YjM2NGNmXCJ9IiwiaWF0IjoxNzU5ODE2MTI0LCJleHAiOjE3NTk4MTY3MjR9.quBfp9UL9Ddqb2CWERXoVkh9OdmHlIBvlLAyhoXElaY"
+      },
+      "field:anrede": "Frau",
+      "formId": "e084006b-ae83-4e4d-b2f5-074118cdb3b1"
+    }
+  },
+  "origin_header": null,
+  "all_headers": {
+    "host": "localhost:8080",
+    "content-type": "application/json",
+    "user-agent": "insomnia/2023.5.8",
+    "accept": "*/*",
+    "content-length": "7335"
+  }
+}

logs/wix_test_data_20251007_160537.json

@@ -0,0 +1,257 @@
+{
+  "timestamp": "2025-10-07T16:05:37.531417",
+  "client_ip": "127.0.0.1",
+  "headers": {
+    "host": "localhost:8080",
+    "content-type": "application/json",
+    "user-agent": "insomnia/2023.5.8",
+    "accept": "*/*",
+    "content-length": "7335"
+  },
+  "data": {
+    "data": {
+      "formName": "Contact us",
+      "submissions": [
+        {
+          "label": "Anreisedatum",
+          "value": "2026-01-02"
+        },
+        {
+          "label": "Abreisedatum",
+          "value": "2026-01-07"
+        },
+        {
+          "label": "Anzahl Erwachsene",
+          "value": "3"
+        },
+        {
+          "label": "Anzahl Kinder",
+          "value": "1"
+        },
+        {
+          "label": "Alter Kind 1",
+          "value": "12"
+        },
+        {
+          "label": "Anrede",
+          "value": "Frau"
+        },
+        {
+          "label": "Vorname",
+          "value": "Genesia "
+        },
+        {
+          "label": "Nachname",
+          "value": "Supino "
+        },
+        {
+          "label": "Email",
+          "value": "supinogenesia@gmail.com"
+        },
+        {
+          "label": "Phone",
+          "value": "+39 340 625 9979"
+        },
+        {
+          "label": "Einwilligung Marketing",
+          "value": "Selezionato"
+        },
+        {
+          "label": "utm_Source",
+          "value": "fb"
+        },
+        {
+          "label": "utm_Medium",
+          "value": "Facebook_Mobile_Feed"
+        },
+        {
+          "label": "utm_Campaign",
+          "value": "Conversions_Hotel_Bemelmans_ITA"
+        },
+        {
+          "label": "utm_Term",
+          "value": "Cold_Traffic_Conversions_Hotel_Bemelmans_ITA"
+        },
+        {
+          "label": "utm_Content",
+          "value": "Grafik_AuszeitDezember_9.12_23.12"
+        },
+        {
+          "label": "utm_term_id",
+          "value": "120238574626400196"
+        },
+        {
+          "label": "utm_content_id",
+          "value": "120238574626400196"
+        },
+        {
+          "label": "gad_source",
+          "value": ""
+        },
+        {
+          "label": "gad_campaignid",
+          "value": ""
+        },
+        {
+          "label": "gbraid",
+          "value": ""
+        },
+        {
+          "label": "gclid",
+          "value": ""
+        },
+        {
+          "label": "fbclid",
+          "value": "IwZXh0bgNhZW0BMABhZGlkAassWPh1b8QBHoRc2S24gMktdNKiPwEvGYMK3rB-mne_0IJQvQRIGH60wLvLfOm0XWP8wJ9s_aem_rbpAFMODwOh4UnF5UVxwWg"
+        },
+        {
+          "label": "hotelid",
+          "value": "12345"
+        },
+        {
+          "label": "hotelname",
+          "value": "Bemelmans Post"
+        }
+      ],
+      "field:date_picker_7e65": "2026-01-07",
+      "field:number_7cf5": "3",
+      "field:utm_source": "fb",
+      "submissionTime": "2025-10-07T05:48:41.855Z",
+      "field:alter_kind_3": "12",
+      "field:gad_source": "",
+      "field:form_field_5a7b": "Selezionato",
+      "field:gad_campaignid": "",
+      "field:utm_medium": "Facebook_Mobile_Feed",
+      "field:utm_term_id": "120238574626400196",
+      "context": {
+        "metaSiteId": "1dea821c-8168-4736-96e4-4b92e8b364cf",
+        "activationId": "2421c9cd-6565-49ba-b60f-165d3dacccba"
+      },
+      "field:email_5139": "supinogenesia@gmail.com",
+      "field:phone_4c77": "+39 340 625 9979",
+      "_context": {
+        "activation": {
+          "id": "2421c9cd-6565-49ba-b60f-165d3dacccba"
+        },
+        "configuration": {
+          "id": "a976f18c-fa86-495d-be1e-676df188eeae"
+        },
+        "app": {
+          "id": "225dd912-7dea-4738-8688-4b8c6955ffc2"
+        },
+        "action": {
+          "id": "152db4d7-5263-40c4-be2b-1c81476318b7"
+        },
+        "trigger": {
+          "key": "wix_form_app-form_submitted"
+        }
+      },
+      "field:gclid": "",
+      "formFieldMask": [
+        "field:",
+        "field:",
+        "field:angebot_auswaehlen",
+        "field:date_picker_a7c8",
+        "field:date_picker_7e65",
+        "field:",
+        "field:number_7cf5",
+        "field:anzahl_kinder",
+        "field:alter_kind_3",
+        "field:alter_kind_25",
+        "field:alter_kind_4",
+        "field:alter_kind_5",
+        "field:alter_kind_6",
+        "field:alter_kind_7",
+        "field:alter_kind_8",
+        "field:alter_kind_9",
+        "field:alter_kind_10",
+        "field:alter_kind_11",
+        "field:",
+        "field:anrede",
+        "field:first_name_abae",
+        "field:last_name_d97c",
+        "field:email_5139",
+        "field:phone_4c77",
+        "field:long_answer_3524",
+        "field:form_field_5a7b",
+        "field:",
+        "field:utm_source",
+        "field:utm_medium",
+        "field:utm_campaign",
+        "field:utm_term",
+        "field:utm_content",
+        "field:utm_term_id",
+        "field:utm_content_id",
+        "field:gad_source",
+        "field:gad_campaignid",
+        "field:gbraid",
+        "field:gclid",
+        "field:fbclid",
+        "field:hotelid",
+        "field:hotelname",
+        "field:",
+        "metaSiteId"
+      ],
+      "contact": {
+        "name": {
+          "first": "Genesia",
+          "last": "Supino"
+        },
+        "email": "supinogenesia@gmail.com",
+        "locale": "it-it",
+        "phones": [
+          {
+            "tag": "UNTAGGED",
+            "formattedPhone": "+39 340 625 9979",
+            "id": "198f04fb-5b2c-4a7b-b7ea-adc150ec4212",
+            "countryCode": "IT",
+            "e164Phone": "+393406259979",
+            "primary": true,
+            "phone": "340 625 9979"
+          }
+        ],
+        "contactId": "4d695011-36c1-4480-b225-ae9c6eef9e83",
+        "emails": [
+          {
+            "id": "e09d7bab-1f11-4b5d-b3c5-32d43c1dc584",
+            "tag": "UNTAGGED",
+            "email": "supinogenesia@gmail.com",
+            "primary": true
+          }
+        ],
+        "updatedDate": "2025-10-07T05:48:44.764Z",
+        "phone": "+393406259979",
+        "createdDate": "2025-10-07T05:48:43.567Z"
+      },
+      "submissionId": "c52702c9-55b9-44e1-b158-ec9544c73cc7",
+      "field:anzahl_kinder": "1",
+      "field:first_name_abae": "Genesia ",
+      "field:utm_content_id": "120238574626400196",
+      "field:utm_campaign": "Conversions_Hotel_Bemelmans_ITA",
+      "field:utm_term": "Cold_Traffic_Conversions_Hotel_Bemelmans_ITA",
+      "contactId": "4d695011-36c1-4480-b225-ae9c6eef9e83",
+      "field:date_picker_a7c8": "2026-01-02",
+      "field:hotelname": "Bemelmans Post",
+      "field:utm_content": "Grafik_AuszeitDezember_9.12_23.12",
+      "field:last_name_d97c": "Supino ",
+      "field:hotelid": "12345",
+      "submissionsLink": "https://manage.wix.app/forms/submissions/1dea821c-8168-4736-96e4-4b92e8b364cf/e084006b-ae83-4e4d-b2f5-074118cdb3b1?d=https%3A%2F%2Fmanage.wix.com%2Fdashboard%2F1dea821c-8168-4736-96e4-4b92e8b364cf%2Fwix-forms%2Fform%2Fe084006b-ae83-4e4d-b2f5-074118cdb3b1%2Fsubmissions&s=true",
+      "field:gbraid": "",
+      "field:fbclid": "IwZXh0bgNhZW0BMABhZGlkAassWPh1b8QBHoRc2S24gMktdNKiPwEvGYMK3rB-mne_0IJQvQRIGH60wLvLfOm0XWP8wJ9s_aem_rbpAFMODwOh4UnF5UVxwWg",
+      "submissionPdf": {
+        "fileName": "c52702c9-55b9-44e1-b158-ec9544c73cc7.pdf",
+        "downloadUrl": "https://manage.wix.com/_api/form-submission-service/v4/submissions/c52702c9-55b9-44e1-b158-ec9544c73cc7/download?accessToken=JWS.eyJraWQiOiJWLVNuLWhwZSIsImFsZyI6IkhTMjU2In0.eyJkYXRhIjoie1wibWV0YVNpdGVJZFwiOlwiMWRlYTgyMWMtODE2OC00NzM2LTk2ZTQtNGI5MmU4YjM2NGNmXCJ9IiwiaWF0IjoxNzU5ODE2MTI0LCJleHAiOjE3NTk4MTY3MjR9.quBfp9UL9Ddqb2CWERXoVkh9OdmHlIBvlLAyhoXElaY"
+      },
+      "field:anrede": "Frau",
+      "formId": "e084006b-ae83-4e4d-b2f5-074118cdb3b1"
+    }
+  },
+  "origin_header": null,
+  "all_headers": {
+    "host": "localhost:8080",
+    "content-type": "application/json",
+    "user-agent": "insomnia/2023.5.8",
+    "accept": "*/*",
+    "content-length": "7335"
+  }
+}

pyproject.toml

@@ -16,6 +16,7 @@ dependencies = [
     "generateds>=2.44.3",
     "httpx>=0.28.1",
     "lxml>=6.0.1",
+    "pydantic[email]>=2.11.9",
     "pytest>=8.4.2",
     "pytest-asyncio>=1.2.0",
     "redis>=6.4.0",

src/alpine_bits_python/alpine_bits_helpers.py

@@ -6,6 +6,14 @@ from enum import Enum
 from typing import Any
 
 from alpine_bits_python.db import Customer, Reservation
+from alpine_bits_python.schemas import (
+    CommentData,
+    CommentListItemData,
+    CommentsData,
+    CustomerData,
+    HotelReservationIdData,
+    PhoneTechType,
+)
 
 # Import the generated classes
 from .generated.alpinebits import (
@@ -21,12 +29,12 @@ _LOGGER = logging.getLogger(__name__)
 _LOGGER.setLevel(logging.INFO)
 
 # Define type aliases for the two Customer types
-NotifCustomer = OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer
+NotifCustomer = OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer  # noqa: E501
-RetrieveCustomer = OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer
+RetrieveCustomer = OtaResRetrieveRs.ReservationsList.HotelReservation.ResGuests.ResGuest.Profiles.ProfileInfo.Profile.Customer  # noqa: E501
 
 # Define type aliases for HotelReservationId types
-NotifHotelReservationId = OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.HotelReservationIds.HotelReservationId
+NotifHotelReservationId = OtaHotelResNotifRq.HotelReservations.HotelReservation.ResGlobalInfo.HotelReservationIds.HotelReservationId  # noqa: E501
-RetrieveHotelReservationId = OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.HotelReservationIds.HotelReservationId
+RetrieveHotelReservationId = OtaResRetrieveRs.ReservationsList.HotelReservation.ResGlobalInfo.HotelReservationIds.HotelReservationId  # noqa: E501
 
 # Define type aliases for Comments types
 NotifComments = (
@@ -67,13 +75,6 @@ NotifHotelReservation = OtaHotelResNotifRq.HotelReservations.HotelReservation
 RetrieveHotelReservation = OtaResRetrieveRs.ReservationsList.HotelReservation
 
 
-# phonetechtype enum 1,3,5 voice, fax, mobile
-class PhoneTechType(Enum):
-    VOICE = "1"
-    FAX = "3"
-    MOBILE = "5"
-
-
 # Enum to specify which OTA message type to use
 class OtaMessageType(Enum):
     NOTIF = "notification"  # For OtaHotelResNotifRq
@@ -87,37 +88,6 @@ class KidsAgeData:
     ages: list[int]
 
 
-@dataclass
-class CustomerData:
-    """Simple data class to hold customer information without nested type constraints."""
-
-    given_name: str
-    surname: str
-    name_prefix: None | str = None
-    name_title: None | str = None
-    phone_numbers: list[tuple[str, None | PhoneTechType]] = (
-        None  # (phone_number, phone_tech_type)
-    )
-    email_address: None | str = None
-    email_newsletter: None | bool = (
-        None  # True for "yes", False for "no", None for not specified
-    )
-    address_line: None | str = None
-    city_name: None | str = None
-    postal_code: None | str = None
-    country_code: None | str = None  # Two-letter country code
-    address_catalog: None | bool = (
-        None  # True for "yes", False for "no", None for not specified
-    )
-    gender: None | str = None  # "Unknown", "Male", "Female"
-    birth_date: None | str = None
-    language: None | str = None  # Two-letter language code
-
-    def __post_init__(self):
-        if self.phone_numbers is None:
-            self.phone_numbers = []
-
-
 class GuestCountsFactory:
     """Factory class to create GuestCounts instances for both OtaHotelResNotifRq and OtaResRetrieveRs."""
 
@@ -128,6 +98,7 @@ class GuestCountsFactory:
         message_type: OtaMessageType = OtaMessageType.RETRIEVE,
     ) -> NotifGuestCounts:
         """Create a GuestCounts object for OtaHotelResNotifRq or OtaResRetrieveRs.
+
         :param adults: Number of adults
         :param kids: List of ages for each kid (optional)
         :return: GuestCounts instance
@@ -146,7 +117,8 @@ class GuestCountsFactory:
     def _create_guest_counts(
         adults: int, kids: list[int] | None, guest_counts_class: type
     ) -> Any:
-        """Internal method to create a GuestCounts object of the specified type.
+        """Create a GuestCounts object of the specified type.
+
         :param adults: Number of adults
         :param kids: List of ages for each kid (optional)
         :param guest_counts_class: The GuestCounts class to instantiate
@@ -172,7 +144,7 @@ class GuestCountsFactory:
 
 
 class CustomerFactory:
-    """Factory class to create Customer instances for both OtaHotelResNotifRq and OtaResRetrieveRs."""
+    """Factory class to create Customer instances for both Retrieve and Notif."""
 
     @staticmethod
     def create_notif_customer(data: CustomerData) -> NotifCustomer:
@@ -185,8 +157,10 @@ class CustomerFactory:
         return CustomerFactory._create_customer(RetrieveCustomer, data)
 
     @staticmethod
-    def _create_customer(customer_class: type, data: CustomerData) -> Any:
+    def _create_customer(
-        """Internal method to create a customer of the specified type."""
+        customer_class: type[RetrieveCustomer | NotifCustomer], data: CustomerData
+    ) -> Any:
+        """Create a customer of the specified type."""
         # Create PersonName
         person_name = customer_class.PersonName(
             given_name=data.given_name,
@@ -259,19 +233,21 @@ class CustomerFactory:
 
     @staticmethod
     def _customer_to_data(customer: Any) -> CustomerData:
-        """Internal method to convert any customer type to CustomerData."""
+        """Convert any customer type to CustomerData."""
         # Extract phone numbers
         phone_numbers = []
         if customer.telephone:
-            for tel in customer.telephone:
+            phone_numbers.extend(
-                phone_numbers.append(
+                [
                     (
                         tel.phone_number,
                         PhoneTechType(tel.phone_tech_type)
                         if tel.phone_tech_type
                         else None,
                     )
-                )
+                    for tel in customer.telephone
+                ]
+            )
 
         # Extract email info
         email_address = None
@@ -324,16 +300,6 @@ class CustomerFactory:
         )
 
 
-@dataclass
-class HotelReservationIdData:
-    """Simple data class to hold hotel reservation ID information without nested type constraints."""
-
-    res_id_type: str  # Required field - pattern: [0-9]+
-    res_id_value: None | str = None  # Max 64 characters
-    res_id_source: None | str = None  # Max 64 characters
-    res_id_source_context: None | str = None  # Max 64 characters
-
-
 class HotelReservationIdFactory:
     """Factory class to create HotelReservationId instances for both OtaHotelResNotifRq and OtaResRetrieveRs."""
 
@@ -359,7 +325,7 @@ class HotelReservationIdFactory:
     def _create_hotel_reservation_id(
         hotel_reservation_id_class: type, data: HotelReservationIdData
     ) -> Any:
-        """Internal method to create a hotel reservation id of the specified type."""
+        """Create a hotel reservation id of the specified type."""
         return hotel_reservation_id_class(
             res_id_type=data.res_id_type,
             res_id_value=data.res_id_value,
@@ -398,39 +364,6 @@ class HotelReservationIdFactory:
         )
 
 
-@dataclass
-class CommentListItemData:
-    """Simple data class to hold comment list item information."""
-
-    value: str  # The text content of the list item
-    list_item: str  # Numeric identifier (pattern: [0-9]+)
-    language: str  # Two-letter language code (pattern: [a-z][a-z])
-
-
-@dataclass
-class CommentData:
-    """Simple data class to hold comment information without nested type constraints."""
-
-    name: CommentName2  # Required: "included services", "customer comment", "additional info"
-    text: str | None = None  # Optional text content
-    list_items: list[CommentListItemData] = None  # Optional list items
-
-    def __post_init__(self):
-        if self.list_items is None:
-            self.list_items = []
-
-
-@dataclass
-class CommentsData:
-    """Simple data class to hold multiple comments (1-3 max)."""
-
-    comments: list[CommentData] = None  # 1-3 comments maximum
-
-    def __post_init__(self):
-        if self.comments is None:
-            self.comments = []
-
-
 class CommentFactory:
     """Factory class to create Comment instances for both OtaHotelResNotifRq and OtaResRetrieveRs."""
 
@@ -503,11 +436,7 @@ class CommentFactory:
                         )
                     )
 
-            # Extract comment data
+            comments_data_list.append(comment)
-            comment_data = CommentData(
-                name=comment.name, text=comment.text, list_items=list_items_data
-            )
-            comments_data_list.append(comment_data)
 
         return CommentsData(comments=comments_data_list)
 
@@ -536,9 +465,11 @@ class ResGuestFactory:
 
     @staticmethod
     def _create_res_guests(
-        res_guests_class: type, customer_class: type, customer_data: CustomerData
+        res_guests_class: type[RetrieveResGuests] | type[NotifResGuests],
+        customer_class: type[NotifCustomer | RetrieveCustomer],
+        customer_data: CustomerData,
     ) -> Any:
-        """Internal method to create complete ResGuests structure."""
+        """Create the complete ResGuests structure."""
         # Create the customer using the existing CustomerFactory
         customer = CustomerFactory._create_customer(customer_class, customer_data)
 
@@ -669,7 +600,9 @@ class AlpineBitsFactory:
         return None
 
 
-def create_res_retrieve_response(list: list[tuple[Reservation, Customer]]):
+def create_res_retrieve_response(
+    list: list[tuple[Reservation, Customer]],
+) -> OtaResRetrieveRs:
     """Create RetrievedReservation XML from database entries."""
     return _create_xml_from_db(list, OtaMessageType.RETRIEVE)
 
@@ -712,8 +645,6 @@ def _process_single_reservation(
         reservation.num_adults, children_ages, message_type
     )
 
-    unique_id_string = reservation.unique_id
-
     if message_type == OtaMessageType.NOTIF:
         UniqueId = NotifUniqueId
         RoomStays = NotifRoomStays
@@ -727,8 +658,10 @@ def _process_single_reservation(
     else:
         raise ValueError("Unsupported message type: %s", message_type.value)
 
+    unique_id_str = reservation.md5_unique_id
+
     # UniqueID
-    unique_id = UniqueId(type_value=UniqueIdType2.VALUE_14, id=unique_id_string)
+    unique_id = UniqueId(type_value=UniqueIdType2.VALUE_14, id=unique_id_str)
 
     # TimeSpan
     time_span = RoomStays.RoomStay.TimeSpan(
@@ -744,20 +677,24 @@ def _process_single_reservation(
     )
 
     res_id_source = "website"
+    klick_id = None
 
     if reservation.fbclid != "":
-        klick_id = reservation.fbclid
+        klick_id = str(reservation.fbclid)
         res_id_source = "meta"
     elif reservation.gclid != "":
-        klick_id = reservation.gclid
+        klick_id = str(reservation.gclid)
         res_id_source = "google"
 
-    # explicitly set klick_id to None otherwise an empty string will be sent
+    # Get utm_medium if available, otherwise use source
-    if klick_id in (None, "", "None"):
+    if reservation.utm_medium is not None and str(reservation.utm_medium) != "":
-        klick_id = None
+        res_id_source = str(reservation.utm_medium)
-    else:  # extract string from Column object
-        klick_id = str(klick_id)
 
+    # Use Pydantic model for automatic validation and truncation
+    # It will automatically:
+    # - Trim whitespace
+    # - Truncate to 64 characters if needed
+    # - Convert empty strings to None
     hotel_res_id_data = HotelReservationIdData(
         res_id_type="13",
         res_id_value=klick_id,
@@ -765,33 +702,6 @@ def _process_single_reservation(
         res_id_source_context="99tales",
     )
 
-    # explicitly set klick_id to None otherwise an empty string will be sent
-    if klick_id in (None, "", "None"):
-        klick_id = None
-    else:  # extract string from Column object
-        klick_id = str(klick_id)
-
-    utm_medium = (
-        str(reservation.utm_medium)
-        if reservation.utm_medium is not None and str(reservation.utm_medium) != ""
-        else "website"
-    )
-
-    # shorten klick_id if longer than 64 characters
-    # TODO MAGIC SHORTENING
-    if klick_id is not None and len(klick_id) > 64:
-        klick_id = klick_id[:64]
-
-    if klick_id == "":
-        klick_id = None
-
-    hotel_res_id_data = HotelReservationIdData(
-        res_id_type="13",
-        res_id_value=klick_id,
-        res_id_source=utm_medium,
-        res_id_source_context="99tales",
-    )
-
     hotel_res_id = alpine_bits_factory.create(hotel_res_id_data, message_type)
     hotel_res_ids = HotelReservation.ResGlobalInfo.HotelReservationIds(
         hotel_reservation_id=[hotel_res_id]
@@ -920,12 +830,12 @@ def _create_xml_from_db(
             _LOGGER.debug(traceback.format_exc())
 
     if type == OtaMessageType.NOTIF:
-        retrieved_reservations = OtaHotelResNotifRq.HotelReservations(
+        res_list_obj = OtaHotelResNotifRq.HotelReservations(
             hotel_reservation=reservations_list
         )
 
         ota_hotel_res_notif_rq = OtaHotelResNotifRq(
-            version="7.000", hotel_reservations=retrieved_reservations
+            version="7.000", hotel_reservations=res_list_obj
         )
 
         try:
@@ -936,12 +846,12 @@ def _create_xml_from_db(
 
         return ota_hotel_res_notif_rq
     if type == OtaMessageType.RETRIEVE:
-        retrieved_reservations = OtaResRetrieveRs.ReservationsList(
+        res_list_obj = OtaResRetrieveRs.ReservationsList(
             hotel_reservation=reservations_list
         )
 
         ota_res_retrieve_rs = OtaResRetrieveRs(
-            version="7.000", success="", reservations_list=retrieved_reservations
+            version="7.000", success="", reservations_list=res_list_obj
         )
 
         try:

src/alpine_bits_python/alpinebits_server.py

@@ -21,12 +21,19 @@ from xsdata.formats.dataclass.serializers.config import SerializerConfig
 from xsdata_pydantic.bindings import XmlParser, XmlSerializer
 
 from alpine_bits_python.alpine_bits_helpers import (
-    create_res_notif_push_message, create_res_retrieve_response)
+    create_res_notif_push_message,
+    create_res_retrieve_response,
+)
 
 from .db import AckedRequest, Customer, Reservation
-from .generated.alpinebits import (OtaNotifReportRq, OtaNotifReportRs,
+from .generated.alpinebits import (
-                                   OtaPingRq, OtaPingRs, OtaReadRq,
+    OtaNotifReportRq,
-                                   WarningStatus)
+    OtaNotifReportRs,
+    OtaPingRq,
+    OtaPingRs,
+    OtaReadRq,
+    WarningStatus,
+)
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -195,8 +202,7 @@ class AlpineBitsAction(ABC):
 
 
 class ServerCapabilities:
-    """Automatically discovers AlpineBitsAction implementations and generates capabilities.
+    """Automatically discovers AlpineBitsAction implementations and generates capabilities."""
-    """
 
     def __init__(self):
         self.action_registry: dict[AlpineBitsActionName, type[AlpineBitsAction]] = {}
@@ -230,9 +236,7 @@ class ServerCapabilities:
         return False
 
     def create_capabilities_dict(self) -> None:
-        """Generate the capabilities dictionary based on discovered actions.
+        """Generate the capabilities dictionary based on discovered actions."""
-
-        """
         versions_dict = {}
 
         for action_enum, action_class in self.action_registry.items():
@@ -280,10 +284,8 @@ class ServerCapabilities:
                     if action.get("action") != "action_OTA_Ping"
                 ]
 
-
     def get_capabilities_dict(self) -> dict:
-        """Get capabilities as a dictionary. Generates if not already created.
+        """Get capabilities as a dictionary. Generates if not already created."""
-        """
         if self.capability_dict is None:
             self.create_capabilities_dict()
         return self.capability_dict
@@ -523,7 +525,7 @@ class ReadAction(AlpineBitsAction):
                 select(Reservation.id)
                 .join(
                     AckedRequest,
-                    AckedRequest.unique_id == Reservation.unique_id,
+                    Reservation.md5_unique_id == AckedRequest.unique_id,
                 )
                 .filter(AckedRequest.client_id == client_info.client_id)
             )
@@ -608,7 +610,9 @@ class NotifReportReadAction(AlpineBitsAction):
             )
 
         timestamp = datetime.now(ZoneInfo("UTC"))
-        for entry in notif_report_details.hotel_notif_report.hotel_reservations.hotel_reservation:  # type: ignore
+        for entry in (
+            notif_report_details.hotel_notif_report.hotel_reservations.hotel_reservation
+        ):  # type: ignore
             unique_id = entry.unique_id.id
             acked_request = AckedRequest(
                 unique_id=unique_id,

src/alpine_bits_python/api.py

@@ -4,8 +4,10 @@ import json
 import logging
 import os
 import urllib.parse
+from collections import defaultdict
 from datetime import UTC, date, datetime
 from functools import partial
+from pathlib import Path
 from typing import Any
 
 import httpx
@@ -16,6 +18,8 @@ from fastapi.security import HTTPBasic, HTTPBasicCredentials
 from slowapi.errors import RateLimitExceeded
 from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
 
+from alpine_bits_python.schemas import ReservationData
+
 from .alpinebits_server import (
     AlpineBitsActionName,
     AlpineBitsClientInfo,
@@ -43,8 +47,6 @@ _LOGGER = logging.getLogger(__name__)
 # HTTP Basic auth for AlpineBits
 security_basic = HTTPBasic()
 
-from collections import defaultdict
-
 
 # --- Enhanced event dispatcher with hotel-specific routing ---
 class EventDispatcher:
@@ -240,42 +242,6 @@ app.add_middleware(
 )
 
 
-async def process_form_submission(submission_data: dict[str, Any]) -> None:
-    """Background task to process the form submission.
-    Add your business logic here.
-    """
-    try:
-        _LOGGER.info(
-            f"Processing form submission: {submission_data.get('submissionId')}"
-        )
-
-        # Example processing - you can replace this with your actual logic
-        form_name = submission_data.get("formName")
-        contact_email = (
-            submission_data.get("contact", {}).get("email")
-            if submission_data.get("contact")
-            else None
-        )
-
-        # Extract form fields
-        form_fields = {
-            k: v for k, v in submission_data.items() if k.startswith("field:")
-        }
-
-        _LOGGER.info(
-            f"Form: {form_name}, Contact: {contact_email}, Fields: {len(form_fields)}"
-        )
-
-        # Here you could:
-        # - Save to database
-        # - Send emails
-        # - Call external APIs
-        # - Process the data further
-
-    except Exception as e:
-        _LOGGER.error(f"Error processing form submission: {e!s}")
-
-
 @api_router.get("/")
 @limiter.limit(DEFAULT_RATE_LIMIT)
 async def root(request: Request):
@@ -307,6 +273,22 @@ async def health_check(request: Request):
     }
 
 
+def create_db_reservation_from_data(
+    reservation_model: ReservationData, db_customer_id: int
+) -> DBReservation:
+    """Convert ReservationData to DBReservation, handling children_ages conversion."""
+    data = reservation_model.model_dump(exclude_none=True)
+
+    children_list = data.pop("children_ages", [])
+    children_csv = ",".join(str(int(a)) for a in children_list) if children_list else ""
+    data["children_ages"] = children_csv
+
+    # Inject FK
+    data["customer_id"] = db_customer_id
+
+    return DBReservation(**data)
+
+
 # Extracted business logic for handling Wix form submissions
 async def process_wix_form_submission(request: Request, data: dict[str, Any], db):
     """Shared business logic for handling Wix form submissions (test and production)."""
@@ -392,24 +374,10 @@ async def process_wix_form_submission(request: Request, data: dict[str, Any], db
 
     offer = data.get("field:angebot_auswaehlen")
 
-    # UTM and offer
-    utm_fields = [
-        ("utm_Source", "utm_source"),
-        ("utm_Medium", "utm_medium"),
-        ("utm_Campaign", "utm_campaign"),
-        ("utm_Term", "utm_term"),
-        ("utm_Content", "utm_content"),
-    ]
-
     # get submissionId and ensure max length 35. Generate one if not present
 
     unique_id = data.get("submissionId", generate_unique_id())
 
-    # TODO MAGIC shortening
-    if len(unique_id) > 32:
-        # strip to first 35 chars
-        unique_id = unique_id[:32]
-
     # use database session
 
     # Save all relevant data to DB (including new fields)
@@ -451,14 +419,15 @@ async def process_wix_form_submission(request: Request, data: dict[str, Any], db
         or "Frangart Inn"  # fallback
     )
 
-    db_reservation = DBReservation(
+    reservation = ReservationData(
-        customer_id=db_customer.id,
         unique_id=unique_id,
-        start_date=date.fromisoformat(start_date) if start_date else None,
+        start_date=date.fromisoformat(start_date),
-        end_date=date.fromisoformat(end_date) if end_date else None,
+        end_date=date.fromisoformat(end_date),
         num_adults=num_adults,
         num_children=num_children,
-        children_ages=",".join(str(a) for a in children_ages),
+        children_ages=children_ages,
+        hotel_code=hotel_code,
+        hotel_name=hotel_name,
         offer=offer,
         created_at=datetime.now(UTC),
         utm_source=data.get("field:utm_source"),
@@ -469,9 +438,12 @@ async def process_wix_form_submission(request: Request, data: dict[str, Any], db
         user_comment=data.get("field:long_answer_3524", ""),
         fbclid=data.get("field:fbclid"),
         gclid=data.get("field:gclid"),
-        hotel_code=hotel_code,
-        hotel_name=hotel_name,
     )
+
+    if reservation.md5_unique_id is None:
+        raise HTTPException(status_code=400, detail="Failed to generate md5_unique_id")
+
+    db_reservation = create_db_reservation_from_data(reservation, db_customer.id)
     db.add(db_reservation)
     await db.commit()
     await db.refresh(db_reservation)
@@ -504,65 +476,6 @@ async def process_wix_form_submission(request: Request, data: dict[str, Any], db
     }
 
 
-@api_router.post("/webhook/wix-form")
-@webhook_limiter.limit(WEBHOOK_RATE_LIMIT)
-async def handle_wix_form(
-    request: Request, data: dict[str, Any], db_session=Depends(get_async_session)
-):
-    """Unified endpoint to handle Wix form submissions (test and production).
-    No authentication required for this endpoint.
-    """
-    try:
-        return await process_wix_form_submission(request, data, db_session)
-    except Exception as e:
-        _LOGGER.error(f"Error in handle_wix_form: {e!s}")
-        # log stacktrace
-        import traceback
-
-        traceback_str = traceback.format_exc()
-        _LOGGER.error(f"Stack trace for handle_wix_form: {traceback_str}")
-        raise HTTPException(status_code=500, detail="Error processing Wix form data")
-
-
-@api_router.post("/webhook/wix-form/test")
-@limiter.limit(DEFAULT_RATE_LIMIT)
-async def handle_wix_form_test(
-    request: Request, data: dict[str, Any], db_session=Depends(get_async_session)
-):
-    """Test endpoint to verify the API is working with raw JSON data.
-    No authentication required for testing purposes.
-    """
-    try:
-        return await process_wix_form_submission(request, data, db_session)
-    except Exception as e:
-        _LOGGER.error(f"Error in handle_wix_form_test: {e!s}")
-        raise HTTPException(status_code=500, detail="Error processing test data")
-
-
-# UNUSED
-@api_router.post("/admin/generate-api-key")
-@limiter.limit("5/hour")  # Very restrictive for admin operations
-async def generate_new_api_key(
-    request: Request, admin_key: str = Depends(validate_api_key)
-):
-    """Admin endpoint to generate new API keys.
-    Requires admin API key and is heavily rate limited.
-    """
-    if admin_key != "admin-key":
-        raise HTTPException(status_code=403, detail="Admin access required")
-
-    new_key = generate_api_key()
-    _LOGGER.info(f"Generated new API key (requested by: {admin_key})")
-
-    return {
-        "status": "success",
-        "message": "New API key generated",
-        "api_key": new_key,
-        "timestamp": datetime.now().isoformat(),
-        "note": "Store this key securely - it won't be shown again",
-    }
-
-
 async def validate_basic_auth(
     credentials: HTTPBasicCredentials = Depends(security_basic),
 ) -> str:
@@ -600,6 +513,128 @@ async def validate_basic_auth(
     return credentials.username, credentials.password
 
 
+@api_router.post("/webhook/wix-form")
+@webhook_limiter.limit(WEBHOOK_RATE_LIMIT)
+async def handle_wix_form(
+    request: Request, data: dict[str, Any], db_session=Depends(get_async_session)
+):
+    """Unified endpoint to handle Wix form submissions (test and production).
+    No authentication required for this endpoint.
+    """
+    try:
+        return await process_wix_form_submission(request, data, db_session)
+    except Exception as e:
+        _LOGGER.error(f"Error in handle_wix_form: {e!s}")
+        # log stacktrace
+        import traceback
+
+        traceback_str = traceback.format_exc()
+        _LOGGER.error(f"Stack trace for handle_wix_form: {traceback_str}")
+        raise HTTPException(status_code=500, detail="Error processing Wix form data")
+
+
+@api_router.post("/webhook/wix-form/test")
+@limiter.limit(DEFAULT_RATE_LIMIT)
+async def handle_wix_form_test(
+    request: Request, data: dict[str, Any], db_session=Depends(get_async_session)
+):
+    """Test endpoint to verify the API is working with raw JSON data.
+    No authentication required for testing purposes.
+    """
+    try:
+        return await process_wix_form_submission(request, data, db_session)
+    except Exception as e:
+        _LOGGER.error(f"Error in handle_wix_form_test: {e!s}")
+        raise HTTPException(status_code=500, detail="Error processing test data")
+
+
+@api_router.post("/hoteldata/conversions_import")
+@limiter.limit(DEFAULT_RATE_LIMIT)
+async def handle_xml_upload(
+    request: Request, credentials_tupel: tuple = Depends(validate_basic_auth)
+):
+    """Endpoint for receiving XML files for conversion processing.
+    Requires basic authentication and saves XML files to log directory.
+    """
+    try:
+        # Get the raw body content
+        body = await request.body()
+
+        if not body:
+            raise HTTPException(
+                status_code=400, detail="ERROR: No XML content provided"
+            )
+
+        # Try to decode as UTF-8
+        try:
+            xml_content = body.decode("utf-8")
+        except UnicodeDecodeError:
+            # If UTF-8 fails, try with latin-1 as fallback
+            xml_content = body.decode("latin-1")
+
+        # Basic validation that it's XML-like
+        if not xml_content.strip().startswith("<"):
+            raise HTTPException(
+                status_code=400, detail="ERROR: Content does not appear to be XML"
+            )
+
+        # Create logs directory for XML conversions
+        logs_dir = Path("logs/conversions_import")
+        if not logs_dir.exists():
+            logs_dir.mkdir(parents=True, mode=0o755, exist_ok=True)
+            _LOGGER.info("Created directory: %s", logs_dir)
+
+        # Generate filename with timestamp and authenticated user
+        username, _ = credentials_tupel
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        log_filename = logs_dir / f"xml_import_{username}_{timestamp}.xml"
+
+        # Save XML content to file
+        log_filename.write_text(xml_content, encoding="utf-8")
+
+        _LOGGER.info("XML file saved to %s by user %s", log_filename, username)
+
+        return {
+            "status": "success",
+            "message": "XML file received and saved",
+            "filename": log_filename.name,
+            "size_bytes": len(body),
+            "authenticated_user": username,
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        _LOGGER.exception("Error in handle_xml_upload")
+        raise HTTPException(
+            status_code=500, detail="Error processing XML upload"
+        ) from e
+
+
+# UNUSED
+@api_router.post("/admin/generate-api-key")
+@limiter.limit("5/hour")  # Very restrictive for admin operations
+async def generate_new_api_key(
+    request: Request, admin_key: str = Depends(validate_api_key)
+):
+    """Admin endpoint to generate new API keys.
+    Requires admin API key and is heavily rate limited.
+    """
+    if admin_key != "admin-key":
+        raise HTTPException(status_code=403, detail="Admin access required")
+
+    new_key = generate_api_key()
+    _LOGGER.info(f"Generated new API key (requested by: {admin_key})")
+
+    return {
+        "status": "success",
+        "message": "New API key generated",
+        "api_key": new_key,
+        "timestamp": datetime.now().isoformat(),
+        "note": "Store this key securely - it won't be shown again",
+    }
+
+
 # TODO Bit sketchy. May need requests-toolkit in the future
 def parse_multipart_data(content_type: str, body: bytes) -> dict[str, Any]:
     """Parse multipart/form-data from raw request body.

src/alpine_bits_python/db.py

@@ -44,7 +44,8 @@ class Reservation(Base):
     __tablename__ = "reservations"
     id = Column(Integer, primary_key=True)
     customer_id = Column(Integer, ForeignKey("customers.id"))
-    unique_id = Column(String(35), unique=True)  # max length 35
+    unique_id = Column(String, unique=True)
+    md5_unique_id = Column(String(32), unique=True)  # max length 32 guaranteed
     start_date = Column(Date)
     end_date = Column(Date)
     num_adults = Column(Integer)

src/alpine_bits_python/schemas.py

@@ -0,0 +1,253 @@
+"""Pydantic models for data validation in AlpineBits.
+
+These models provide validation for data before it's passed to:
+- SQLAlchemy database models
+- AlpineBits XML generation
+- API endpoints
+
+Separating validation (Pydantic) from persistence (SQLAlchemy) and
+from XML generation (xsdata) follows clean architecture principles.
+"""
+
+import hashlib
+from datetime import date
+from enum import Enum
+
+from pydantic import BaseModel, EmailStr, Field, field_validator, model_validator
+
+
+# phonetechtype enum 1,3,5 voice, fax, mobile
+class PhoneTechType(Enum):
+    VOICE = "1"
+    FAX = "3"
+    MOBILE = "5"
+
+
+class PhoneNumber(BaseModel):
+    """Phone number with optional type."""
+
+    number: str = Field(..., min_length=1, max_length=50, pattern=r"^\+?[0-9\s\-()]+$")
+    tech_type: str | None = Field(None, pattern="^[135]$")  # 1=voice, 3=fax, 5=mobile
+
+    @field_validator("number")
+    @classmethod
+    def clean_phone_number(cls, v: str) -> str:
+        """Remove extra spaces from phone number."""
+        return " ".join(v.split())
+
+
+class ReservationData(BaseModel):
+    """Validated reservation data."""
+
+    unique_id: str = Field(..., min_length=1, max_length=200)
+    md5_unique_id: str | None = Field(None, min_length=1, max_length=32)
+    start_date: date
+    end_date: date
+    num_adults: int = Field(..., ge=1)
+    num_children: int = Field(0, ge=0, le=10)
+    children_ages: list[int] = Field(default_factory=list)
+    hotel_code: str = Field(..., min_length=1, max_length=50)
+    hotel_name: str | None = Field(None, max_length=200)
+    offer: str | None = Field(None, max_length=500)
+    user_comment: str | None = Field(None, max_length=2000)
+    fbclid: str | None = Field(None, max_length=100)
+    gclid: str | None = Field(None, max_length=100)
+    utm_source: str | None = Field(None, max_length=100)
+    utm_medium: str | None = Field(None, max_length=100)
+    utm_campaign: str | None = Field(None, max_length=100)
+    utm_term: str | None = Field(None, max_length=100)
+    utm_content: str | None = Field(None, max_length=100)
+
+    @model_validator(mode="after")
+    def ensure_md5(self) -> "ReservationData":
+        """Ensure md5_unique_id is set after model validation.
+
+        Using a model_validator in 'after' mode lets us access all fields via
+        the instance and set md5_unique_id in-place when it wasn't provided.
+        """
+        if not getattr(self, "md5_unique_id", None) and getattr(
+            self, "unique_id", None
+        ):
+            self.md5_unique_id = hashlib.md5(self.unique_id.encode("utf-8")).hexdigest()
+        return self
+
+    @model_validator(mode="after")
+    def validate_children_ages(self) -> "ReservationData":
+        """Ensure children_ages matches num_children."""
+        if len(self.children_ages) != self.num_children:
+            raise ValueError(
+                f"Number of children ages ({len(self.children_ages)}) "
+                f"must match num_children ({self.num_children})"
+            )
+        for age in self.children_ages:
+            if age < 0 or age > 17:
+                raise ValueError(f"Child age {age} must be between 0 and 17")
+        return self
+
+
+class CustomerData(BaseModel):
+    """Validated customer data for creating reservations and guests."""
+
+    given_name: str = Field(..., min_length=1, max_length=100)
+    surname: str = Field(..., min_length=1, max_length=100)
+    name_prefix: str | None = Field(None, max_length=20)
+    name_title: str | None = Field(None, max_length=20)
+    phone_numbers: list[tuple[str, None | PhoneTechType]] = Field(default_factory=list)
+    email_address: EmailStr | None = None
+    email_newsletter: bool | None = None
+    address_line: str | None = Field(None, max_length=255)
+    city_name: str | None = Field(None, max_length=100)
+    postal_code: str | None = Field(None, max_length=20)
+    country_code: str | None = Field(
+        None, min_length=2, max_length=2, pattern="^[A-Z]{2}$"
+    )
+    address_catalog: bool | None = None
+    gender: str | None = Field(None, pattern="^(Male|Female|Unknown)$")
+    birth_date: str | None = Field(None, pattern=r"^\d{4}-\d{2}-\d{2}$")  # ISO format
+    language: str | None = Field(None, min_length=2, max_length=2, pattern="^[a-z]{2}$")
+
+    @field_validator("given_name", "surname")
+    @classmethod
+    def name_must_not_be_empty(cls, v: str) -> str:
+        """Ensure names are not just whitespace."""
+        if not v.strip():
+            raise ValueError("Name cannot be empty or whitespace")
+        return v.strip()
+
+    @field_validator("country_code")
+    @classmethod
+    def normalize_country_code(cls, v: str | None) -> str | None:
+        """Normalize country code to uppercase."""
+        return v.upper() if v else None
+
+    @field_validator("language")
+    @classmethod
+    def normalize_language(cls, v: str | None) -> str | None:
+        """Normalize language code to lowercase."""
+        return v.lower() if v else None
+
+    model_config = {"from_attributes": True}  # Allow creation from ORM models
+
+
+class HotelReservationIdData(BaseModel):
+    """Validated hotel reservation ID data."""
+
+    res_id_type: str = Field(..., pattern=r"^[0-9]+$")  # Must be numeric string
+    res_id_value: str | None = Field(None, min_length=1, max_length=64)
+    res_id_source: str | None = Field(None, min_length=1, max_length=64)
+    res_id_source_context: str | None = Field(None, min_length=1, max_length=64)
+
+    @field_validator(
+        "res_id_value", "res_id_source", "res_id_source_context", mode="before"
+    )
+    @classmethod
+    def trim_and_truncate(cls, v: str | None) -> str | None:
+        """Trim whitespace and truncate to max length if needed.
+
+        Runs BEFORE field validation to ensure values are cleaned and truncated
+        before max_length constraints are checked.
+        """
+        if not v:
+            return None
+        # Convert to string if needed
+        v = str(v)
+        # Strip whitespace
+        v = v.strip()
+        # Convert empty strings to None
+        if not v:
+            return None
+        # Truncate to 64 characters if needed
+        if len(v) > 64:
+            v = v[:64]
+        return v
+
+    model_config = {"from_attributes": True}
+
+
+class CommentListItemData(BaseModel):
+    """Validated comment list item."""
+
+    value: str = Field(..., min_length=1, max_length=1000)
+    list_item: str = Field(..., pattern=r"^[0-9]+$")  # Numeric identifier
+    language: str = Field(..., min_length=2, max_length=2, pattern=r"^[a-z]{2}$")
+
+    @field_validator("language")
+    @classmethod
+    def normalize_language(cls, v: str) -> str:
+        """Normalize language to lowercase."""
+        return v.lower()
+
+    model_config = {"from_attributes": True}
+
+
+class CommentData(BaseModel):
+    """Validated comment data."""
+
+    name: str  # Should be validated against CommentName2 enum
+    text: str | None = Field(None, max_length=4000)
+    list_items: list[CommentListItemData] = Field(default_factory=list)
+
+    @field_validator("list_items")
+    @classmethod
+    def validate_list_items(
+        cls, v: list[CommentListItemData]
+    ) -> list[CommentListItemData]:
+        """Ensure list items have unique identifiers."""
+        if v:
+            item_ids = [item.list_item for item in v]
+            if len(item_ids) != len(set(item_ids)):
+                raise ValueError("List items must have unique identifiers")
+        return v
+
+    model_config = {"from_attributes": True}
+
+
+class CommentsData(BaseModel):
+    """Validated comments collection."""
+
+    comments: list[CommentData] = Field(default_factory=list, max_length=3)
+
+    @field_validator("comments")
+    @classmethod
+    def validate_comment_count(cls, v: list[CommentData]) -> list[CommentData]:
+        """Ensure maximum 3 comments."""
+        if len(v) > 3:
+            raise ValueError("Maximum 3 comments allowed")
+        return v
+
+    model_config = {"from_attributes": True}
+
+
+# Example usage in a service layer
+class ReservationService:
+    """Example service showing how to use Pydantic models with SQLAlchemy."""
+
+    def __init__(self, db_session):
+        self.db_session = db_session
+
+    async def create_reservation(
+        self, reservation_data: ReservationData, customer_data: CustomerData
+    ):
+        """Create a reservation with validated data.
+
+        The data has already been validated by Pydantic before reaching here.
+        """
+        from alpine_bits_python.db import Customer, Reservation
+
+        # Convert validated Pydantic model to SQLAlchemy model
+        db_customer = Customer(**customer_data.model_dump(exclude_none=True))
+        self.db_session.add(db_customer)
+        await self.db_session.flush()  # Get the customer ID
+
+        # Create reservation linked to customer
+        db_reservation = Reservation(
+            customer_id=db_customer.id,
+            **reservation_data.model_dump(
+                exclude={"children_ages"}
+            ),  # Handle separately
+            children_ages=",".join(map(str, reservation_data.children_ages)),
+        )
+        self.db_session.add(db_reservation)
+        await self.db_session.commit()
+
+        return db_reservation, db_customer

tests/test_alpine_bits_server_read.py

@@ -1,2 +1,455 @@
+"""Tests for AlpineBits server read action.
+
+This module tests the ReadAction handler which retrieves reservations
+from the database and returns them as OTA_ResRetrieveRS XML.
+"""
+
+from datetime import UTC, date, datetime
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from xsdata.formats.dataclass.serializers.config import SerializerConfig
+from xsdata_pydantic.bindings import XmlParser, XmlSerializer
+
+from alpine_bits_python.alpine_bits_helpers import create_res_retrieve_response
+from alpine_bits_python.alpinebits_server import AlpineBitsClientInfo
+from alpine_bits_python.db import Base, Customer, Reservation
+from alpine_bits_python.generated import OtaReadRq
+from alpine_bits_python.generated.alpinebits import OtaResRetrieveRs
+from alpine_bits_python.schemas import ReservationData
 
 
+@pytest.fixture
+async def test_db_engine():
+    """Create an in-memory SQLite database for testing."""
+    engine = create_async_engine(
+        "sqlite+aiosqlite:///:memory:",
+        echo=False,
+    )
+
+    # Create tables
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+    yield engine
+
+    # Cleanup
+    await engine.dispose()
+
+
+@pytest.fixture
+async def test_db_session(test_db_engine):
+    """Create a test database session."""
+    async_session = async_sessionmaker(
+        test_db_engine,
+        class_=AsyncSession,
+        expire_on_commit=False,
+    )
+
+    async with async_session() as session:
+        yield session
+
+
+@pytest.fixture
+def sample_customer():
+    """Create a sample customer for testing."""
+    return Customer(
+        id=1,
+        given_name="John",
+        surname="Doe",
+        contact_id="CONTACT-12345",
+        name_prefix="Mr.",
+        name_title="Jr.",
+        email_address="john.doe@example.com",
+        phone="+1234567890",
+        email_newsletter=True,
+        address_line="123 Main Street",
+        city_name="Anytown",
+        postal_code="12345",
+        country_code="US",
+        gender="Male",
+        birth_date="1980-01-01",
+        language="en",
+        address_catalog=False,
+    )
+
+
+@pytest.fixture
+def sample_reservation(sample_customer):
+    """Create a sample reservation for testing."""
+    reservation = ReservationData(
+        unique_id="RES-2024-001",
+        start_date=date(2024, 12, 25),
+        end_date=date(2024, 12, 31),
+        num_adults=2,
+        num_children=1,
+        children_ages=[8],
+        offer="Christmas Special",
+        created_at=datetime.now(UTC),
+        utm_source="google",
+        utm_medium="cpc",
+        utm_campaign="winter2024",
+        utm_term="ski resort",
+        utm_content="ad1",
+        user_comment="Late check-in requested",
+        fbclid="",
+        gclid="abc123xyz",
+        hotel_code="HOTEL123",
+        hotel_name="Alpine Paradise Resort",
+    )
+    data = reservation.model_dump(exclude_none=True)
+
+    children_list = data.pop("children_ages", [])
+    children_csv = ",".join(str(int(a)) for a in children_list) if children_list else ""
+    data["children_ages"] = children_csv
+
+    print(data)
+
+    return Reservation(
+        id=1,
+        customer_id=1,
+        **data,
+        customer=sample_customer,
+    )
+
+
+@pytest.fixture
+def minimal_customer():
+    """Create a minimal customer with only required fields."""
+    return Customer(
+        id=2,
+        given_name="Jane",
+        surname="Smith",
+        contact_id="CONTACT-67890",
+    )
+
+
+@pytest.fixture
+def minimal_reservation(minimal_customer):
+    """Create a minimal reservation with only required fields."""
+    reservation = ReservationData(
+        unique_id="RES-2024-002",
+        start_date=date(2025, 1, 15),
+        end_date=date(2025, 1, 20),
+        num_adults=1,
+        num_children=0,
+        children_ages=[],
+        hotel_code="HOTEL123",
+        created_at=datetime.now(UTC),
+        hotel_name="Alpine Paradise Resort",
+    )
+
+    data = reservation.model_dump(exclude_none=True)
+
+    children_list = data.pop("children_ages", [])
+    children_csv = ",".join(str(int(a)) for a in children_list) if children_list else ""
+    data["children_ages"] = children_csv
+
+    return Reservation(
+        id=2,
+        customer_id=2,
+        **data,
+        customer=minimal_customer,
+    )
+
+
+@pytest.fixture
+def read_request_xml():
+    """Sample OTA_ReadRQ XML request."""
+    return """<?xml version="1.0" encoding="UTF-8"?>
+<OTA_ReadRQ xmlns="http://www.opentravel.org/OTA/2003/05"
+            EchoToken="12345"
+            TimeStamp="2024-10-07T10:00:00"
+            Version="8.000">
+    <ReadRequests>
+        <HotelReadRequest HotelCode="HOTEL123" HotelName="Alpine Paradise Resort">
+            <SelectionCriteria Start="2024-12-01" End="2025-01-31"/>
+        </HotelReadRequest>
+    </ReadRequests>
+</OTA_ReadRQ>"""
+
+
+@pytest.fixture
+def read_request_xml_no_date_filter():
+    """Sample OTA_ReadRQ XML request without date filter."""
+    return """<?xml version="1.0" encoding="UTF-8"?>
+<OTA_ReadRQ xmlns="http://www.opentravel.org/OTA/2003/05"
+            EchoToken="12345"
+            TimeStamp="2024-10-07T10:00:00"
+            Version="8.000">
+    <ReadRequests>
+        <HotelReadRequest HotelCode="HOTEL123" HotelName="Alpine Paradise Resort"/>
+    </ReadRequests>
+</OTA_ReadRQ>"""
+
+
+@pytest.fixture
+def test_config():
+    """Test configuration with hotel credentials."""
+    return {
+        "hotels": [
+            {
+                "hotel_id": "HOTEL123",
+                "username": "testuser",
+                "password": "testpass",
+            }
+        ]
+    }
+
+
+@pytest.fixture
+def client_info():
+    """Sample client info for testing."""
+    return AlpineBitsClientInfo(
+        username="testuser",
+        password="testpass",
+        client_id="CLIENT-001",
+    )
+
+
+class TestCreateResRetrieveResponse:
+    """Test the create_res_retrieve_response function."""
+
+    def test_empty_list(self):
+        """Test creating response with empty reservation list."""
+        response = create_res_retrieve_response([])
+
+        assert response is not None, "Response should not be None"
+
+        # check that response is of correct type
+        assert isinstance(response, OtaResRetrieveRs), (
+            "Response should be of type OtaResRetrieveRs"
+        )
+
+        assert hasattr(response, "success"), "Response should have success attribute"
+
+        assert hasattr(response, "reservations_list"), (
+            "Response should have reservations_list attribute"
+        )
+
+    def test_single_reservation(self, sample_reservation, sample_customer):
+        """Test creating response with single reservation."""
+        reservation_pairs = [(sample_reservation, sample_customer)]
+        response = create_res_retrieve_response(reservation_pairs)
+
+        assert response is not None
+        assert hasattr(response, "reservations_list"), (
+            "Response should have reservations_list attribute"
+        )
+
+        assert hasattr(response.reservations_list, "hotel_reservation"), (
+            "reservations_list should have reservation attribute"
+        )
+
+        assert len(response.reservations_list.hotel_reservation) == 1
+        res: OtaResRetrieveRs.ReservationsList.HotelReservation = (
+            response.reservations_list.hotel_reservation[0]
+        )
+
+        assert res.unique_id is not None, "Reservation should have unique_id"
+        # Verify the response can be serialized to XML
+        config = SerializerConfig(
+            pretty_print=True, xml_declaration=True, encoding="UTF-8"
+        )
+        serializer = XmlSerializer(config=config)
+        xml_output = serializer.render(
+            response, ns_map={None: "http://www.opentravel.org/OTA/2003/05"}
+        )
+
+        assert xml_output is not None
+        # assert "RES-2024-001" in xml_output does not work due to hashing
+        assert "John" in xml_output
+        assert "Doe" in xml_output
+        assert "HOTEL123" in xml_output
+
+    def test_multiple_reservations(
+        self,
+        sample_reservation,
+        sample_customer,
+        minimal_reservation,
+        minimal_customer,
+    ):
+        """Test creating response with multiple reservations."""
+        reservation_pairs = [
+            (sample_reservation, sample_customer),
+            (minimal_reservation, minimal_customer),
+        ]
+        response = create_res_retrieve_response(reservation_pairs)
+
+        assert response is not None
+
+        # Serialize to XML and verify both reservations are present
+        config = SerializerConfig(
+            pretty_print=True, xml_declaration=True, encoding="UTF-8"
+        )
+        serializer = XmlSerializer(config=config)
+        xml_output = serializer.render(
+            response, ns_map={None: "http://www.opentravel.org/OTA/2003/05"}
+        )
+
+        # assert "RES-2024-001" in xml_output
+        # assert "RES-2024-002" in xml_output
+        assert "John" in xml_output
+        assert "Jane" in xml_output
+
+    def test_reservation_with_children(self, sample_reservation, sample_customer):
+        """Test reservation with children ages."""
+        sample_reservation.num_children = 2
+        sample_reservation.children_ages = "8,5"
+
+        reservation_pairs = [(sample_reservation, sample_customer)]
+        response = create_res_retrieve_response(reservation_pairs)
+
+        config = SerializerConfig(pretty_print=True)
+        serializer = XmlSerializer(config=config)
+        xml_output = serializer.render(
+            response, ns_map={None: "http://www.opentravel.org/OTA/2003/05"}
+        )
+
+        assert response is not None
+        # Children should be represented in guest counts
+        assert "GuestCount" in xml_output or "Child" in xml_output
+
+
+class TestXMLParsing:
+    """Test XML parsing and generation."""
+
+    def test_parse_read_request(self, read_request_xml):
+        """Test parsing of OTA_ReadRQ XML."""
+        parser = XmlParser()
+        read_request = parser.from_string(read_request_xml, OtaReadRq)
+
+        assert read_request is not None
+        assert read_request.read_requests is not None
+        assert read_request.read_requests.hotel_read_request is not None
+
+        hotel_req = read_request.read_requests.hotel_read_request
+        assert hotel_req.hotel_code == "HOTEL123"
+        assert hotel_req.hotel_name == "Alpine Paradise Resort"
+        assert hotel_req.selection_criteria is not None
+        assert hotel_req.selection_criteria.start == "2024-12-01"
+
+    def test_parse_read_request_no_date(self, read_request_xml_no_date_filter):
+        """Test parsing of OTA_ReadRQ without date filter."""
+        parser = XmlParser()
+        read_request = parser.from_string(read_request_xml_no_date_filter, OtaReadRq)
+
+        assert read_request is not None
+        hotel_req = read_request.read_requests.hotel_read_request
+        assert hotel_req.hotel_code == "HOTEL123"
+        assert hotel_req.selection_criteria is None
+
+    def test_serialize_retrieve_response(
+        self,
+        sample_reservation,
+        sample_customer,
+    ):
+        """Test serialization of retrieve response to XML."""
+        reservation_pairs = [(sample_reservation, sample_customer)]
+        response = create_res_retrieve_response(reservation_pairs)
+
+        config = SerializerConfig(
+            pretty_print=True, xml_declaration=True, encoding="UTF-8"
+        )
+        serializer = XmlSerializer(config=config)
+        xml_output = serializer.render(
+            response, ns_map={None: "http://www.opentravel.org/OTA/2003/05"}
+        )
+
+        # Verify it's valid XML
+        assert xml_output.startswith('<?xml version="1.0" encoding="UTF-8"?>')
+        assert "OTA_ResRetrieveRS" in xml_output
+
+        # Verify customer data is present
+        assert "John" in xml_output
+        assert "Doe" in xml_output
+        assert "john.doe@example.com" in xml_output
+
+        # Verify reservation data is present
+        # assert "RES-2024-001" in xml_output
+        assert "HOTEL123" in xml_output
+
+
+class TestEdgeCases:
+    """Test edge cases and error conditions."""
+
+    def test_customer_with_special_characters(self):
+        """Test customer with special characters in name."""
+        customer = Customer(
+            id=99,
+            given_name="François",
+            surname="O'Brien-Smith",
+            contact_id="CONTACT-SPECIAL",
+        )
+        reservation = Reservation(
+            id=99,
+            customer_id=99,
+            unique_id="RES-SPECIAL",
+            start_date=date(2025, 1, 1),
+            end_date=date(2025, 1, 5),
+            num_adults=1,
+            num_children=0,
+            children_ages="",
+            hotel_code="HOTEL123",
+            created_at=datetime.now(UTC),
+        )
+
+        reservation_pairs = [(reservation, customer)]
+        response = create_res_retrieve_response(reservation_pairs)
+
+        config = SerializerConfig(pretty_print=True, encoding="UTF-8")
+        serializer = XmlSerializer(config=config)
+        xml_output = serializer.render(
+            response, ns_map={None: "http://www.opentravel.org/OTA/2003/05"}
+        )
+
+        assert response is not None
+        assert xml_output is not None
+
+    def test_reservation_with_all_utm_parameters(self):
+        """Test reservation with all UTM tracking parameters."""
+        customer = Customer(
+            id=97,
+            given_name="Marketing",
+            surname="Test",
+            contact_id="CONTACT-97",
+        )
+        reservation = ReservationData(
+            unique_id="RES-UTM-TEST",
+            start_date=date(2025, 2, 1),
+            end_date=date(2025, 2, 7),
+            num_adults=2,
+            num_children=0,
+            children_ages=[],
+            hotel_code="HOTEL123",
+            created_at=datetime.now(UTC),
+            utm_source="facebook",
+            utm_medium="social",
+            utm_campaign="spring2025",
+            utm_term="luxury resort",
+            utm_content="carousel_ad",
+            fbclid="IwAR1234567890",
+            gclid="",
+        )
+
+        reservation_db = Reservation(
+            id=97,
+            customer_id=97,
+            **reservation.model_dump(exclude_none=True),
+        )
+
+        reservation_pairs = [(reservation_db, customer)]
+        response = create_res_retrieve_response(reservation_pairs)
+
+        config = SerializerConfig(pretty_print=True)
+        serializer = XmlSerializer(config=config)
+        xml_output = serializer.render(
+            response, ns_map={None: "http://www.opentravel.org/OTA/2003/05"}
+        )
+
+        assert response is not None
+        # UTM parameters should be in comments or other fields
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tests/test_alpinebits_server_ping.py

@@ -17,15 +17,11 @@ def extract_relevant_sections(xml_string):
 
 @pytest.mark.asyncio
 async def test_ping_action_response_matches_expected():
-    with open("test/test_data/Handshake-OTA_PingRQ.xml", encoding="utf-8") as f:
+    with open("tests/test_data/Handshake-OTA_PingRQ.xml", encoding="utf-8") as f:
         server = AlpineBitsServer()
-        with open(
+        with open("tests/test_data/Handshake-OTA_PingRQ.xml", encoding="utf-8") as f:
-            "test/test_data/Handshake-OTA_PingRQ.xml", encoding="utf-8"
-        ) as f:
             request_xml = f.read()
-        with open(
+        with open("tests/test_data/Handshake-OTA_PingRS.xml", encoding="utf-8") as f:
-            "test/test_data/Handshake-OTA_PingRS.xml", encoding="utf-8"
-        ) as f:
             expected_xml = f.read()
         client_info = AlpineBitsClientInfo(username="irrelevant", password="irrelevant")
         response = await server.handle_request(
@@ -56,7 +52,7 @@ async def test_ping_action_response_matches_expected():
 @pytest.mark.asyncio
 async def test_ping_action_response_success():
     server = AlpineBitsServer()
-    with open("test/test_data/Handshake-OTA_PingRQ.xml", encoding="utf-8") as f:
+    with open("tests/test_data/Handshake-OTA_PingRQ.xml", encoding="utf-8") as f:
         request_xml = f.read()
     client_info = AlpineBitsClientInfo(username="irrelevant", password="irrelevant")
     response = await server.handle_request(
@@ -74,7 +70,7 @@ async def test_ping_action_response_success():
 @pytest.mark.asyncio
 async def test_ping_action_response_version_arbitrary():
     server = AlpineBitsServer()
-    with open("test/test_data/Handshake-OTA_PingRQ.xml", encoding="utf-8") as f:
+    with open("tests/test_data/Handshake-OTA_PingRQ.xml", encoding="utf-8") as f:
         request_xml = f.read()
     client_info = AlpineBitsClientInfo(username="irrelevant", password="irrelevant")
     response = await server.handle_request(
@@ -91,7 +87,7 @@ async def test_ping_action_response_version_arbitrary():
 @pytest.mark.asyncio
 async def test_ping_action_response_invalid_action():
     server = AlpineBitsServer()
-    with open("test/test_data/Handshake-OTA_PingRQ.xml", encoding="utf-8") as f:
+    with open("tests/test_data/Handshake-OTA_PingRQ.xml", encoding="utf-8") as f:
         request_xml = f.read()
     client_info = AlpineBitsClientInfo(username="irrelevant", password="irrelevant")
     response = await server.handle_request(

uv.lock

@@ -26,6 +26,7 @@ dependencies = [
     { name = "generateds" },
     { name = "httpx" },
     { name = "lxml" },
+    { name = "pydantic", extra = ["email"] },
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "redis" },
@@ -47,6 +48,7 @@ requires-dist = [
     { name = "generateds", specifier = ">=2.44.3" },
     { name = "httpx", specifier = ">=0.28.1" },
     { name = "lxml", specifier = ">=6.0.1" },
+    { name = "pydantic", extras = ["email"], specifier = ">=2.11.9" },
     { name = "pytest", specifier = ">=8.4.2" },
     { name = "pytest-asyncio", specifier = ">=1.2.0" },
     { name = "redis", specifier = ">=6.4.0" },
@@ -206,6 +208,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6e/c6/ac0b6c1e2d138f1002bcf799d330bd6d85084fece321e662a14223794041/Deprecated-1.2.18-py2.py3-none-any.whl", hash = "sha256:bd5011788200372a32418f888e326a09ff80d0214bd961147cfed01b5c018eec", size = 9998, upload-time = "2025-01-27T10:46:09.186Z" },
 ]
 
+[[package]]
+name = "dnspython"
+version = "2.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/8b/57666417c0f90f08bcafa776861060426765fdb422eb10212086fb811d26/dnspython-2.8.0.tar.gz", hash = "sha256:181d3c6996452cb1189c4046c61599b84a5a86e099562ffde77d26984ff26d0f", size = 368251, upload-time = "2025-09-07T18:58:00.022Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/5a/18ad964b0086c6e62e2e7500f7edc89e3faa45033c71c1893d34eed2b2de/dnspython-2.8.0-py3-none-any.whl", hash = "sha256:01d9bbc4a2d76bf0db7c1f729812ded6d912bd318d3b1cf81d30c0f845dbf3af", size = 331094, upload-time = "2025-09-07T18:57:58.071Z" },
+]
+
 [[package]]
 name = "docformatter"
 version = "1.7.7"
@@ -230,6 +241,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b2/b7/545d2c10c1fc15e48653c91efde329a790f2eecfbbf2bd16003b5db2bab0/dotenv-0.9.9-py2.py3-none-any.whl", hash = "sha256:29cf74a087b31dafdb5a446b6d7e11cbce8ed2741540e2339c69fbef92c94ce9", size = 1892, upload-time = "2025-02-19T22:15:01.647Z" },
 ]
 
+[[package]]
+name = "email-validator"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "dnspython" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/22/900cb125c76b7aaa450ce02fd727f452243f2e91a61af068b40adba60ea9/email_validator-2.3.0.tar.gz", hash = "sha256:9fc05c37f2f6cf439ff414f8fc46d917929974a82244c20eb10231ba60c54426", size = 51238, upload-time = "2025-08-26T13:09:06.831Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/15/545e2b6cf2e3be84bc1ed85613edd75b8aea69807a71c26f4ca6a9258e82/email_validator-2.3.0-py3-none-any.whl", hash = "sha256:80f13f623413e6b197ae73bb10bf4eb0908faf509ad8362c5edeb0be7fd450b4", size = 35604, upload-time = "2025-08-26T13:09:05.858Z" },
+]
+
 [[package]]
 name = "fastapi"
 version = "0.117.1"
@@ -508,6 +532,11 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3e/d3/108f2006987c58e76691d5ae5d200dd3e0f532cb4e5fa3560751c3a1feba/pydantic-2.11.9-py3-none-any.whl", hash = "sha256:c42dd626f5cfc1c6950ce6205ea58c93efa406da65f479dcb4029d5934857da2", size = 444855, upload-time = "2025-09-13T11:26:36.909Z" },
 ]
 
+[package.optional-dependencies]
+email = [
+    { name = "email-validator" },
+]
+
 [[package]]
 name = "pydantic-core"
 version = "2.33.2"