init

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

app/api/messages/parser.py

@@ -3,6 +3,7 @@ from datetime import datetime
 from uuid import UUID
 
 from app.api.messages.schemas import Message
+from app.api.participants.schemas import Participant
 from app.core.config import (
     ENCODING_ASCII,
     ENCODING_UTF8,
@@ -13,7 +14,7 @@ from app.core.config import (
     TABLE_PARTICIPANTS,
     TABLE_TOPICS,
 )
-from app.core.link import Link
+from app.core.link import Link, TopicLink, ParticipantLink
 
 
 class MessageLineParser:
@@ -49,9 +50,9 @@ class MessageLineParser:
 
         return Message(
             id=UUID(message_id),
-            topic_id=Link.from_raw(topic_raw, default_table=TABLE_TOPICS),
+            topic_id=Link.from_raw(topic_raw),
             order_in_topic=int(order_in_topic),
-            participant_id=Link.from_raw(participant_raw, default_table=TABLE_PARTICIPANTS),
+            participant_id=Link.from_raw(participant_raw),
             created_at=datetime.fromisoformat(created_at_value),
             content=cls._decode_content(encoded_content),
         )

app/api/messages/schemas.py

@@ -4,12 +4,12 @@ from uuid import UUID
 from pydantic import BaseModel, Field
 
 from app.core.config import TOPIC_MESSAGE_MAX_LENGTH, TOPIC_MESSAGE_MIN_LENGTH
-from app.core.link import Link
+from app.core.link import Link, ParticipantLink, TopicLink
 
 
 class MessageBase(BaseModel):
-    topic_id: Link
-    participant_id: Link
+    topic_id: TopicLink
+    participant_id: ParticipantLink
     content: str = Field(min_length=TOPIC_MESSAGE_MIN_LENGTH, max_length=TOPIC_MESSAGE_MAX_LENGTH)
 
 

app/api/messages/services.py

@@ -13,6 +13,7 @@ from app.core.config import (
     FORBIDDEN_WORDS,
     FORBIDDEN_WORDS_MESSAGE,
     PARTICIPANT_NOT_FOUND_MESSAGE,
+    MESSAGE_NOT_FOUND_MESSAGE,
     TABLE_PARTICIPANTS,
     TABLE_TOPICS,
     TOPIC_NOT_FOUND_MESSAGE,
@@ -126,3 +127,16 @@ class MessageService:
         self.file_manager.append_line(serialized)
         return message
 
+    def get_message(self, message_id: UUID) -> Message:
+        for message in self.list_messages():
+            if message.id == message_id:
+                return message
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=MESSAGE_NOT_FOUND_MESSAGE,
+        )
+
+    def export_message(self, message_id: UUID) -> str:
+        message = self.get_message(message_id)
+        return MessageLineParser.serialize(message)
+

app/api/messages/views.py

@@ -11,33 +11,40 @@ from app.api.topics.schemas import Topic
 from app.core.config import (
     MESSAGES_FILE,
     PARTICIPANTS_FILE,
+    TABLE_PARTICIPANTS,
     TABLE_TOPICS,
     TOPICS_FILE,
     UNKNOWN_PARTICIPANT_NAME,
     UNKNOWN_TOPIC_TITLE,
 )
 from app.core.file_manager import FileManager
-from app.core.link import Link
+from app.core.link import Link, ParticipantLink, TopicLink
 
 
 router = APIRouter()
-message_service = MessageService(FileManager(MESSAGES_FILE), FileManager(TOPICS_FILE), FileManager(PARTICIPANTS_FILE))
+message_service = MessageService(
+    FileManager(MESSAGES_FILE), FileManager(TOPICS_FILE), FileManager(PARTICIPANTS_FILE)
+)
 participant_service = ParticipantService(FileManager(PARTICIPANTS_FILE))
 topic_file_manager = FileManager(TOPICS_FILE)
 
 
-def _resolve_participant_name(participant_id: Link, participants: List[Participant]) -> str:
-    for participant in participants:
-        if participant.id == participant_id.value:
-            return f"{participant.first_name} {participant.last_name}".strip()
-    return UNKNOWN_PARTICIPANT_NAME
-
-
-def _resolve_topic_title(topic_id: Link, topics: List[Topic]) -> str:
-    for topic in topics:
-        if topic.id == topic_id.value:
-            return topic.title
-    return UNKNOWN_TOPIC_TITLE
+def _resolve_link_value(link: Link, participants: List[Participant], topics: List[Topic]) -> str:
+    resolvers = {
+        TABLE_PARTICIPANTS: lambda identifier: next(
+            (
+                f"{participant.first_name} {participant.last_name}".strip()
+                for participant in participants
+                if participant.id == identifier
+            ),
+            UNKNOWN_PARTICIPANT_NAME,
+        ),
+        TABLE_TOPICS: lambda identifier: next(
+            (topic.title for topic in topics if topic.id == identifier),
+            UNKNOWN_TOPIC_TITLE,
+        ),
+    }
+    return link.resolve(resolvers)
 
 
 def _list_topics() -> List[Topic]:
@@ -52,7 +59,9 @@ def _list_topics() -> List[Topic]:
     return topics
 
 
-def _message_to_response(message: Message, participants: List[Participant], topics: List[Topic]) -> MessageResponse:
+def _message_to_response(
+    message: Message, participants: List[Participant], topics: List[Topic]
+) -> MessageResponse:
     return MessageResponse(
         id=message.id,
         topic_id=message.topic_id,
@@ -60,8 +69,8 @@ def _message_to_response(message: Message, participants: List[Participant], topi
         participant_id=message.participant_id,
         created_at=message.created_at,
         content=message.content,
-        participant_name=_resolve_participant_name(message.participant_id, participants),
-        topic_title=_resolve_topic_title(message.topic_id, topics),
+        participant_name=_resolve_link_value(message.participant_id, participants, topics),
+        topic_title=_resolve_link_value(message.topic_id, participants, topics),
     )
 
 
@@ -76,10 +85,27 @@ async def list_messages() -> List[MessageResponse]:
 
 @router.get("/topic/{topic_id}", response_model=List[MessageResponse])
 async def list_messages_by_topic(topic_id: UUID) -> List[MessageResponse]:
-    topic_link = Link(table=TABLE_TOPICS, value=topic_id)
+    topic_link = TopicLink(value=topic_id)
     message_service.get_topic(topic_link)
     messages = message_service.list_messages_by_topic(topic_link)
     participants = participant_service.list_participants()
     topics = _list_topics()
     return [_message_to_response(message, participants, topics) for message in messages]
 
+
+@router.get("/{message_id}/download")
+async def download_message(message_id: UUID) -> dict:
+    message = message_service.get_message(message_id)
+    participants = participant_service.list_participants()
+    topics = _list_topics()
+    response = _message_to_response(message, participants, topics)
+    return {
+        "id": str(response.id),
+        "topic_id": {"table": response.topic_id.table, "value": str(response.topic_id.value)},
+        "participant_id": {"table": response.participant_id.table, "value": str(response.participant_id.value)},
+        "content": response.content,
+        "order_in_topic": response.order_in_topic,
+        "created_at": response.created_at.isoformat(),
+        "participant_name": response.participant_name,
+        "topic_title": response.topic_title,
+    }

app/api/participants/services.py

@@ -45,5 +45,9 @@ class ParticipantService:
         self.file_manager.append_line(serialized)
         return participant
 
+    def export_participant(self, participant_id: UUID) -> str:
+        participant = self.get_participant(participant_id)
+        return ParticipantLineParser.serialize(participant)
+
 
 

app/api/participants/views.py

@@ -28,4 +28,17 @@ async def create_participant(payload: ParticipantCreate) -> Participant:
     return participant_service.create_participant(payload)
 
 
+@router.get("/{participant_id}/download")
+async def download_participant(participant_id: UUID) -> dict:
+    participant = participant_service.get_participant(participant_id)
+    return {
+        "id": str(participant.id),
+        "first_name": participant.first_name,
+        "last_name": participant.last_name,
+        "nickname": participant.nickname,
+        "activity_rating": participant.activity_rating,
+        "registered_at": participant.registered_at.isoformat(),
+    }
+
+
 

app/api/topics/parser.py

@@ -16,7 +16,7 @@ from app.core.config import (
     TOPIC_PARSE_INVALID_ERROR,
     TOPIC_SEPARATOR,
 )
-from app.core.link import Link
+from app.core.link import Link, ParticipantLink
 
 
 class TopicLineParser:
@@ -35,14 +35,14 @@ class TopicLineParser:
         return base64.b64encode(value.encode(ENCODING_UTF8)).decode(ENCODING_ASCII)
 
     @classmethod
-    def _parse_participants(cls, raw: str) -> List[Link]:
+    def _parse_participants(cls, raw: str) -> List[ParticipantLink]:
         if not raw:
             return []
-        links: List[Link] = []
+        links: List[ParticipantLink] = []
         for value in raw.split(cls.INNER_SEPARATOR):
             if not value:
                 continue
-            links.append(Link.from_raw(value, default_table=TABLE_PARTICIPANTS))
+            links.append(ParticipantLink.from_raw(value))
         return links
 
     @classmethod
@@ -59,14 +59,14 @@ class TopicLineParser:
                 continue
             messages.append(
                 TopicMessage(
-                    participant_id=Link.from_raw(participant_raw, default_table=TABLE_PARTICIPANTS),
+                    participant_id=ParticipantLink.from_raw(participant_raw),
                     content=cls._decode_message(encoded_content),
                 )
             )
         return messages
 
     @classmethod
-    def _serialize_participants(cls, participants: List[Link]) -> str:
+    def _serialize_participants(cls, participants: List[ParticipantLink]) -> str:
         return cls.INNER_SEPARATOR.join(participant.as_path() for participant in participants)
 
     @classmethod

app/api/topics/schemas.py

@@ -12,11 +12,11 @@ from app.core.config import (
     TOPIC_TITLE_MAX_LENGTH,
     TOPIC_TITLE_MIN_LENGTH,
 )
-from app.core.link import Link
+from app.core.link import ParticipantLink
 
 
 class TopicMessageBase(BaseModel):
-    participant_id: Link
+    participant_id: ParticipantLink
     content: str = Field(min_length=TOPIC_MESSAGE_MIN_LENGTH, max_length=TOPIC_MESSAGE_MAX_LENGTH)
     order_in_topic: int | None = None
 
@@ -39,7 +39,7 @@ class TopicBase(BaseModel):
         min_length=TOPIC_DESCRIPTION_MIN_LENGTH,
         max_length=TOPIC_DESCRIPTION_MAX_LENGTH,
     )
-    participants: List[Link] = Field(default_factory=list)
+    participants: List[ParticipantLink] = Field(default_factory=list)
 
 
 class TopicCreate(TopicBase):
@@ -51,7 +51,7 @@ class Topic(BaseModel):
     title: str
     description: str
     created_at: datetime
-    participants: List[Link] = Field(default_factory=list)
+    participants: List[ParticipantLink] = Field(default_factory=list)
     messages: List[TopicMessage] = Field(default_factory=list)
 
 
@@ -62,5 +62,5 @@ class TopicResponse(TopicBase):
 
 
 class AddMessageRequest(BaseModel):
-    participant_id: Link
+    participant_id: ParticipantLink
     content: str = Field(min_length=TOPIC_MESSAGE_MIN_LENGTH, max_length=TOPIC_MESSAGE_MAX_LENGTH)

app/api/topics/services.py

@@ -15,7 +15,7 @@ from app.core.config import (
     TOPIC_NOT_FOUND_MESSAGE,
 )
 from app.core.file_manager import FileManager
-from app.core.link import Link
+from app.core.link import Link, TopicLink, ParticipantLink
 
 
 class TopicService:
@@ -74,7 +74,7 @@ class TopicService:
             for message in payload.messages:
                 self.message_service.create_message(
                     MessageCreate(
-                        topic_id=Link(table=TABLE_TOPICS, value=topic.id),
+                        topic_id=TopicLink(value=topic.id),
                         participant_id=message.participant_id,
                         content=message.content,
                     )
@@ -102,8 +102,8 @@ class TopicService:
         if self.message_service:
             self.message_service.create_message(
                 MessageCreate(
-                    topic_id=Link(table=TABLE_TOPICS, value=resolved_id),
-                    participant_id=payload.participant_id,
+                    topic_id=TopicLink(value=resolved_id),
+                    participant_id=ParticipantLink(value=payload.participant_id.value),
                     content=payload.content,
                 )
             )
@@ -132,3 +132,7 @@ class TopicService:
         self.file_manager.write_lines(lines)
 
         return topics[topic_index]
+
+    def export_topic(self, topic_id: UUID | Link) -> str:
+        topic = self.get_topic(topic_id)
+        return TopicLineParser.serialize(topic)

app/api/topics/views.py

@@ -19,12 +19,11 @@ from app.core.config import (
     HTTP_STATUS_CREATED,
     MESSAGES_FILE,
     PARTICIPANTS_FILE,
-    TABLE_TOPICS,
     TOPICS_FILE,
     UNKNOWN_PARTICIPANT_NAME,
 )
 from app.core.file_manager import FileManager
-from app.core.link import Link
+from app.core.link import Link, TopicLink
 
 
 router = APIRouter()
@@ -77,7 +76,7 @@ async def list_topics() -> List[TopicResponse]:
 
 @router.get("/{topic_id}", response_model=TopicResponse)
 async def get_topic(topic_id: UUID) -> TopicResponse:
-    topic_link = Link(table=TABLE_TOPICS, value=topic_id)
+    topic_link = TopicLink(value=topic_id)
     topic = topic_service.get_topic(topic_link)
     participants = participant_service.list_participants()
     topic_messages = message_service.list_messages_by_topic(topic_link)
@@ -88,14 +87,39 @@ async def get_topic(topic_id: UUID) -> TopicResponse:
 async def create_topic(payload: TopicCreate) -> TopicResponse:
     topic = topic_service.create_topic(payload)
     participants = participant_service.list_participants()
-    topic_messages = message_service.list_messages_by_topic(Link(table=TABLE_TOPICS, value=topic.id))
+    topic_messages = message_service.list_messages_by_topic(TopicLink(value=topic.id))
     return _topic_to_response(topic, participants, topic_messages)
 
 
 @router.post("/{topic_id}/messages", response_model=TopicResponse, status_code=HTTP_STATUS_CREATED)
 async def add_message(topic_id: UUID, payload: AddMessageRequest) -> TopicResponse:
-    topic_link = Link(table=TABLE_TOPICS, value=topic_id)
+    topic_link = TopicLink(value=topic_id)
     topic = topic_service.add_message(topic_link, payload)
     participants = participant_service.list_participants()
     topic_messages = message_service.list_messages_by_topic(topic_link)
     return _topic_to_response(topic, participants, topic_messages)
+
+
+@router.get("/{topic_id}/download")
+async def download_topic(topic_id: UUID) -> dict:
+    topic_link = TopicLink(value=topic_id)
+    topic = topic_service.get_topic(topic_link)
+    participants = participant_service.list_participants()
+    topic_messages = message_service.list_messages_by_topic(topic_link)
+    response = _topic_to_response(topic, participants, topic_messages)
+    return {
+        "id": str(response.id),
+        "title": response.title,
+        "description": response.description,
+        "created_at": response.created_at.isoformat(),
+        "participants": [{"table": p.table, "value": str(p.value)} for p in response.participants],
+        "messages": [
+            {
+                "participant_id": {"table": m.participant_id.table, "value": str(m.participant_id.value)},
+                "content": m.content,
+                "participant_name": m.participant_name,
+                "order_in_topic": m.order_in_topic,
+            }
+            for m in response.messages
+        ],
+    }

app/core/config.py

@@ -25,6 +25,11 @@ MESSAGE_EXPECTED_PARTS = 6
 ENCODING_UTF8 = "utf-8"
 ENCODING_ASCII = "ascii"
 NEWLINE = "\n"
+ALPHABET = (
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "0123456789"
+    r"""!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ """
+)
 
 NAME_MIN_LENGTH = 1
 NAME_MAX_LENGTH = 100

app/core/crypto.py

@@ -0,0 +1,103 @@
+import os
+from typing import List, Tuple
+
+from dotenv import load_dotenv
+
+from app.core.config import ALPHABET, ENCODING_UTF8
+
+
+ENV_KEY_SHIFT = 5
+
+
+class ShiftCipher:
+    @staticmethod
+    def _shift_char(ch: str, shift: int) -> str:
+        index = ALPHABET.find(ch)
+        if index == -1:
+            raise ValueError(f"Character '{ch}' is not in the configured alphabet")
+        return ALPHABET[(index + shift) % len(ALPHABET)]
+
+    @staticmethod
+    def apply(data: bytes, shift: int) -> bytes:
+        text = data.decode(ENCODING_UTF8)
+        shifted = "".join(ShiftCipher._shift_char(ch, shift) for ch in text)
+        return shifted.encode(ENCODING_UTF8)
+
+    @staticmethod
+    def transform_text(value: str, shift: int) -> str:
+        return "".join(ShiftCipher._shift_char(ch, shift) for ch in value)
+
+class LZ78Codec:
+    @staticmethod
+    def compress(text: str) -> bytes:
+        dictionary: dict[str, int] = {}
+        current = ""
+        output: List[Tuple[int, str]] = []
+        for ch in text:
+            candidate = current + ch
+            if candidate in dictionary:
+                current = candidate
+                continue
+            index = dictionary.get(current, 0)
+            output.append((index, ch))
+            dictionary[candidate] = len(dictionary) + 1
+            current = ""
+        if current:
+            output.append((dictionary.get(current, 0), ""))
+        serialized = ";".join(f"{index}:{ord(ch) if ch else -1}" for index, ch in output)
+        return serialized.encode(ENCODING_UTF8)
+
+    @staticmethod
+    def decompress(data: bytes) -> str:
+        if not data:
+            return ""
+        serialized = data.decode(ENCODING_UTF8)
+        if not serialized:
+            return ""
+        pairs: List[Tuple[int, str]] = []
+        for chunk in serialized.split(";"):
+            if not chunk:
+                continue
+            index_part, code_part = chunk.split(":", 1)
+            idx = int(index_part)
+            code = int(code_part)
+            ch = "" if code == -1 else chr(code)
+            pairs.append((idx, ch))
+        dictionary: dict[int, str] = {0: ""}
+        result_parts: List[str] = []
+        for idx, ch in pairs:
+            prefix = dictionary.get(idx, "")
+            entry = prefix + ch
+            result_parts.append(entry)
+            dictionary[len(dictionary)] = entry
+        return "".join(result_parts)
+
+
+class DataCipher:
+    def __init__(self, key: str) -> None:
+        self.key = key
+        self.shift = self._derive_shift(key)
+
+    @staticmethod
+    def _derive_shift(key: str) -> int:
+        value = sum(ord(ch) for ch in key) % 256
+        return value if value else 1
+
+    def encrypt(self, plain: str) -> str:
+        compressed = LZ78Codec.compress(plain)
+        encrypted = ShiftCipher.apply(compressed, self.shift)
+        return encrypted.hex()
+
+    def decrypt(self, encoded: str) -> str:
+        encrypted = bytes.fromhex(encoded)
+        decrypted = ShiftCipher.apply(encrypted, -self.shift)
+        return LZ78Codec.decompress(decrypted)
+
+
+def load_encryption_key() -> str:
+    load_dotenv()
+    encrypted_key = os.getenv("APP_KEY_ENC")
+    if not encrypted_key:
+        raise RuntimeError("APP_KEY_ENC is not set")
+    return ShiftCipher.transform_text(encrypted_key, -ENV_KEY_SHIFT)
+

app/core/file_manager.py

@@ -2,26 +2,50 @@ from pathlib import Path
 from typing import Iterable, List
 
 from app.core.config import ENCODING_UTF8, NEWLINE
+from app.core.crypto import DataCipher, load_encryption_key
 
 
 class FileManager:
+    _cipher_instance: DataCipher | None = None
+
     def __init__(self, file_path: Path) -> None:
         self.file_path = file_path
         self.file_path.parent.mkdir(parents=True, exist_ok=True)
         self.file_path.touch(exist_ok=True)
+        self._cipher = self._get_cipher()
+
+    @classmethod
+    def _get_cipher(cls) -> DataCipher:
+        if cls._cipher_instance is None:
+            cls._cipher_instance = DataCipher(load_encryption_key())
+        return cls._cipher_instance
+
+    def _decode_line(self, raw: str) -> str:
+        try:
+            return self._cipher.decrypt(raw)
+        except Exception:
+            return raw
+
+    def _encode_line(self, plain: str) -> str:
+        return self._cipher.encrypt(plain)
 
     def read_lines(self) -> List[str]:
         with self.file_path.open("r", encoding=ENCODING_UTF8) as file:
-            return [line.rstrip(NEWLINE) for line in file if line.strip()]
+            decoded: List[str] = []
+            for line in file:
+                if not line.strip():
+                    continue
+                decoded.append(self._decode_line(line.rstrip(NEWLINE)))
+            return decoded
 
     def write_lines(self, lines: Iterable[str]) -> None:
         with self.file_path.open("w", encoding=ENCODING_UTF8) as file:
             for line in lines:
-                file.write(f"{line}{NEWLINE}")
+                file.write(f"{self._encode_line(line)}{NEWLINE}")
 
     def append_line(self, line: str) -> None:
         with self.file_path.open("a", encoding=ENCODING_UTF8) as file:
-            file.write(f"{line}{NEWLINE}")
+            file.write(f"{self._encode_line(line)}{NEWLINE}")
 
 
 

app/core/link.py

@@ -2,7 +2,9 @@ from typing import Any, Callable
 from uuid import UUID
 
 from fastapi import HTTPException, status
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
+
+from app.core.config import TABLE_PARTICIPANTS, TABLE_TOPICS
 
 
 class Link(BaseModel):
@@ -23,16 +25,28 @@ class Link(BaseModel):
         return f"/{path}" if leading_slash else path
 
     @classmethod
-    def from_raw(cls, raw: str, default_table: str | None = None) -> "Link":
+    def from_raw(cls, raw: str) -> "Link":
         text = raw.strip()
         if not text:
             raise ValueError("Cannot parse empty link value")
         normalized = text.lstrip("/")
-        if "/" in normalized:
-            table, value = normalized.split("/", 1)
-        else:
-            if default_table is None:
-                raise ValueError("Link table is missing")
-            table, value = default_table, normalized
-        return cls(table=table, value=UUID(value))
+        table, value = normalized.split("/", 1)
+        link_cls = LINK_TYPE_REGISTRY.get(table, Link)
+        if link_cls is Link:
+            return link_cls(table=table, value=UUID(value))
+        return link_cls(value=UUID(value))
+
+
+class TopicLink(Link):
+    table: str = Field(default=TABLE_TOPICS)
+
+
+class ParticipantLink(Link):
+    table: str = Field(default=TABLE_PARTICIPANTS)
+
+
+LINK_TYPE_REGISTRY: dict[str, type[Link]] = {
+    TABLE_TOPICS: TopicLink,
+    TABLE_PARTICIPANTS: ParticipantLink,
+}
 

client.py

@@ -5,6 +5,8 @@ from uuid import UUID
 import httpx
 
 BASE_URL = "http://127.0.0.1:8000"
+TABLE_PARTICIPANTS = "participants"
+TABLE_TOPICS = "topics"
 
 NEWLINE = "\n"
 SEPARATOR_60 = "=" * 60
@@ -77,6 +79,10 @@ class ForumClient:
         self.base_url = base_url
         self.client = httpx.Client(timeout=30.0)
 
+    @staticmethod
+    def _link(table: str, value: str) -> dict:
+        return {"table": table, "value": value}
+
     def get_participants(self) -> list:
         response = self.client.get(f"{self.base_url}/participants/")
         response.raise_for_status()
@@ -126,7 +132,7 @@ class ForumClient:
         payload = {
             "title": title,
             "description": description,
-            "participants": participants or [],
+            "participants": [self._link(TABLE_PARTICIPANTS, p) for p in (participants or [])],
             "messages": [],
         }
         response = self.client.post(f"{self.base_url}/topics/", json=payload)
@@ -137,7 +143,7 @@ class ForumClient:
         self, topic_id: str, participant_id: str, content: str
     ) -> dict | str:
         payload = {
-            "participant_id": participant_id,
+            "participant_id": self._link(TABLE_PARTICIPANTS, participant_id),
             "content": content,
         }
         response = self.client.post(

client2.py

@@ -0,0 +1,1005 @@
+import json
+import re
+from datetime import date, datetime
+from enum import IntEnum
+from pathlib import Path
+from typing import Any, List, Optional, Callable
+
+import httpx
+
+BASE_URL = "https://brestok-vika-server.hf.space"
+DOWNLOADS_DIR = Path(__file__).parent / "downloads"
+SEPARATOR = "=" * 70
+PROMPT = "Select option: "
+
+GENRES = [
+    "Fiction",
+    "Non-Fiction",
+    "Mystery",
+    "Sci-Fi",
+    "Fantasy",
+    "Biography",
+    "History",
+    "Romance",
+    "Thriller",
+    "Horror",
+    "Poetry",
+    "Drama",
+    "Comics",
+    "Other",
+]
+
+BOOK_STATUSES = ["Available", "Borrowed"]
+
+WORK_DAYS = [
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday",
+    "Sunday",
+]
+
+NAME_PATTERN = re.compile(r"^[A-Za-zА-Яа-яЁёІіЇїЄєҐґ\s\-']+$")
+TITLE_PATTERN = re.compile(r"^[A-Za-zА-Яа-яЁёІіЇїЄєҐґ0-9\s\-'.,!?:;\"()]+$")
+UUID_PATTERN = re.compile(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
+
+# Validation error messages
+MSG_IS_REQUIRED = "is required."
+MSG_AT_LEAST_2_CHARS = "must be at least 2 characters."
+MSG_AT_MOST_50_CHARS = "must be at most 50 characters."
+MSG_ONLY_LETTERS_SPACES_HYPHENS_APOSTROPHES = "must contain only letters, spaces, hyphens, and apostrophes."
+MSG_AT_MOST_100_CHARS = "must be at most 100 characters."
+MSG_CONTAINS_INVALID_CHARS = "contains invalid characters."
+MSG_AUTHOR_REQUIRED = "Author is required."
+MSG_AUTHOR_AT_LEAST_2_CHARS = "Author must be at least 2 characters."
+MSG_AUTHOR_AT_MOST_100_CHARS = "Author must be at most 100 characters."
+MSG_AUTHOR_ONLY_LETTERS = "Author must contain only letters, spaces, hyphens, and apostrophes."
+MSG_PAGES_AT_LEAST_1 = "Pages must be at least 1."
+MSG_PAGES_AT_MOST_10000 = "Pages must be at most 10000."
+MSG_YEAR_AT_LEAST_1000 = "Year must be at least 1000."
+MSG_YEAR_CANNOT_BE_GREATER = "Year cannot be greater than {current_year}."
+MSG_GENRE_MUST_BE_ONE_OF = "Genre must be one of: {', '.join(GENRES)}"
+MSG_STATUS_MUST_BE_ONE_OF = "Status must be one of: {', '.join(BOOK_STATUSES)}"
+MSG_EXPERIENCE_NEGATIVE = "Experience cannot be negative."
+MSG_EXPERIENCE_AT_MOST_60 = "Experience must be at most 60 years."
+MSG_AT_LEAST_ONE_WORK_DAY = "At least one work day is required."
+MSG_INVALID_WORK_DAYS = "Invalid work days: {', '.join(invalid)}. Valid options: {', '.join(WORK_DAYS)}"
+MSG_MUST_BE_VALID_UUID = "must be a valid UUID format."
+MSG_DATE_YYYY_MM_DD = "Date must be in YYYY-MM-DD format."
+MSG_AT_LEAST_ONE_ITEM_REQUIRED = "At least one item is required."
+MSG_ITEM_EMPTY = "Item #{i} is empty."
+MSG_ITEM_INVALID_UUID = "Item #{i} ({id_val}) is not a valid UUID."
+
+# Error and info messages
+MSG_ERROR_ENTER_VALID_INTEGER = "  Error: Enter a valid integer."
+MSG_ERROR_INVALID_CHOICE = "  Error: Invalid choice."
+MSG_ERROR_INVALID_NUMBER = "  Error: Invalid number {p}."
+MSG_ERROR_INVALID_VALUE = "  Error: Invalid value '{p}'."
+MSG_ERROR_AT_LEAST_ONE_VALUE = "  Error: At least one value is required."
+MSG_ERROR_BOOK_NOT_FOUND = "  Error: Book with ID {book_id} not found."
+MSG_ERROR_BOOK_NOT_FOUND_VALIDATED = "  Error: Book with ID {validated} not found."
+MSG_ERROR_VISITOR_NOT_FOUND = "  Error: Visitor with ID {validated} not found."
+MSG_ERROR_WORKER_NOT_FOUND = "  Error: Worker with ID {validated} not found."
+MSG_NO_BOOKS_FOUND = "No books found."
+MSG_NO_VISITORS_FOUND = "No visitors found."
+MSG_NO_WORKERS_FOUND = "No workers found."
+MSG_ERROR_PREFIX = "Error: "
+MSG_INVALID_OPTION = "Invalid option."
+MSG_GOODBYE = "Goodbye."
+MSG_NO_FIELDS_TO_UPDATE = "No fields to update."
+MSG_DELETED = "Deleted."
+MSG_FILE_SAVED_TO = "File saved to: "
+MSG_CURRENT_BOOKS = "\nCurrent books:"
+MSG_HISTORY = "\nHistory:"
+MSG_VISITOR_DELETED = "Visitor deleted."
+MSG_WORKER_DELETED = "Worker deleted."
+MSG_INTERRUPTED_GOODBYE = "\nInterrupted. Goodbye."
+
+# Prompts and labels
+MSG_USE_COMMA_OR_STAR = "Use comma to separate values or type * for all."
+MSG_ENTER_NUMBERS_OR_NAMES = "Enter numbers or names: "
+MSG_USE_COMMA_STAR_OR_EMPTY = "Use comma to separate values, * for all, or leave empty to skip."
+MSG_ENTER_NUMBERS_OR_NAMES_EMPTY_SKIP = "Enter numbers or names (empty to skip): "
+MSG_PICK_NUMBER = "Pick number: "
+MSG_PICK_NUMBER_SKIP = "Pick number (0 to skip): "
+MSG_BOOK_ID_PROMPT = "Book ID: "
+MSG_BOOK_IDS_COMMA_SEPARATED = "Book IDs (comma separated): "
+MSG_VISITOR_ID_PROMPT = "Visitor ID: "
+MSG_WORKER_ID_PROMPT = "Worker ID: "
+MSG_TITLE_PROMPT = "Title: "
+MSG_AUTHOR_PROMPT = "Author: "
+MSG_PAGES_PROMPT = "Pages: "
+MSG_YEAR_PROMPT = "Year: "
+MSG_GENRE_PROMPT = "Genre:"
+MSG_STATUS_PROMPT = "Status:"
+MSG_NAME_PROMPT = "Name: "
+MSG_SURNAME_PROMPT = "Surname: "
+MSG_EXPERIENCE_PROMPT = "Experience (years): "
+MSG_WORK_DAYS_PROMPT = "Work days:"
+MSG_SELECT_WORK_DAYS = "Select work days:"
+MSG_TITLE_SKIP_PROMPT = "Title (empty to skip): "
+MSG_AUTHOR_SKIP_PROMPT = "Author (empty to skip): "
+MSG_PAGES_SKIP_PROMPT = "Pages (empty to skip): "
+MSG_YEAR_SKIP_PROMPT = "Year (empty to skip): "
+MSG_NAME_SKIP_PROMPT = "Name (empty to skip): "
+MSG_SURNAME_SKIP_PROMPT = "Surname (empty to skip): "
+MSG_EXPERIENCE_SKIP_PROMPT = "Experience (empty to skip): "
+MSG_LEAVE_EMPTY_TO_SKIP = "Leave fields empty to skip them."
+MSG_BORROW_DATE_PROMPT = "Borrow date (YYYY-MM-DD)"
+MSG_RETURN_DATE_PROMPT = "Return date (YYYY-MM-DD)"
+
+
+class ValidationError(Exception):
+    pass
+
+
+def ensure_downloads_dir():
+    DOWNLOADS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def save_to_file(table: str, entity_id: str, content: str) -> str:
+    ensure_downloads_dir()
+    safe_id = entity_id.replace("/", "_").replace("\\", "_")
+    filename = f"{table}-{safe_id}.json"
+    filepath = DOWNLOADS_DIR / filename
+    if isinstance(content, (dict, list)):
+        text = json.dumps(content, ensure_ascii=False, indent=2)
+    else:
+        try:
+            parsed = json.loads(content)
+            text = json.dumps(parsed, ensure_ascii=False, indent=2)
+        except Exception:
+            text = content
+    filepath.write_text(text, encoding="utf-8")
+    return str(filepath)
+
+
+def validate_name(value: str, field_name: str = "Name") -> str:
+    value = value.strip()
+    if not value:
+        raise ValidationError(f"{field_name} {MSG_IS_REQUIRED}")
+    if len(value) < 2:
+        raise ValidationError(f"{field_name} {MSG_AT_LEAST_2_CHARS}")
+    if len(value) > 50:
+        raise ValidationError(f"{field_name} {MSG_AT_MOST_50_CHARS}")
+    if not NAME_PATTERN.match(value):
+        raise ValidationError(f"{field_name} {MSG_ONLY_LETTERS_SPACES_HYPHENS_APOSTROPHES}")
+    return value
+
+
+def validate_title(value: str, field_name: str = "Title") -> str:
+    value = value.strip()
+    if not value:
+        raise ValidationError(f"{field_name} {MSG_IS_REQUIRED}")
+    if len(value) < 2:
+        raise ValidationError(f"{field_name} {MSG_AT_LEAST_2_CHARS}")
+    if len(value) > 100:
+        raise ValidationError(f"{field_name} {MSG_AT_MOST_100_CHARS}")
+    if not TITLE_PATTERN.match(value):
+        raise ValidationError(f"{field_name} {MSG_CONTAINS_INVALID_CHARS}")
+    return value
+
+
+def validate_author(value: str) -> str:
+    value = value.strip()
+    if not value:
+        raise ValidationError(MSG_AUTHOR_REQUIRED)
+    if len(value) < 2:
+        raise ValidationError(MSG_AUTHOR_AT_LEAST_2_CHARS)
+    if len(value) > 100:
+        raise ValidationError(MSG_AUTHOR_AT_MOST_100_CHARS)
+    if not NAME_PATTERN.match(value):
+        raise ValidationError(MSG_AUTHOR_ONLY_LETTERS)
+    return value
+
+
+def validate_pages(value: int) -> int:
+    if value < 1:
+        raise ValidationError(MSG_PAGES_AT_LEAST_1)
+    if value > 10000:
+        raise ValidationError(MSG_PAGES_AT_MOST_10000)
+    return value
+
+
+def validate_year(value: int) -> int:
+    current_year = date.today().year
+    if value < 1000:
+        raise ValidationError(MSG_YEAR_AT_LEAST_1000)
+    if value > current_year:
+        raise ValidationError(MSG_YEAR_CANNOT_BE_GREATER)
+    return value
+
+
+def validate_genre(value: str) -> str:
+    if value not in GENRES:
+        raise ValidationError(MSG_GENRE_MUST_BE_ONE_OF)
+    return value
+
+
+def validate_status(value: str) -> str:
+    if value not in BOOK_STATUSES:
+        raise ValidationError(MSG_STATUS_MUST_BE_ONE_OF)
+    return value
+
+
+def validate_experience(value: int) -> int:
+    if value < 0:
+        raise ValidationError(MSG_EXPERIENCE_NEGATIVE)
+    if value > 60:
+        raise ValidationError(MSG_EXPERIENCE_AT_MOST_60)
+    return value
+
+
+def validate_work_days(days: List[str]) -> List[str]:
+    if not days:
+        raise ValidationError(MSG_AT_LEAST_ONE_WORK_DAY)
+    invalid = [d for d in days if d not in WORK_DAYS]
+    if invalid:
+        raise ValidationError(MSG_INVALID_WORK_DAYS)
+    return days
+
+
+def validate_uuid(value: str, field_name: str = "ID") -> str:
+    value = value.strip()
+    if not value:
+        raise ValidationError(f"{field_name} {MSG_IS_REQUIRED}")
+    if not UUID_PATTERN.match(value):
+        raise ValidationError(f"{field_name} {MSG_MUST_BE_VALID_UUID}")
+    return value
+
+
+def validate_date(value: str) -> str:
+    value = value.strip()
+    if not value:
+        return date.today().isoformat()
+    try:
+        datetime.strptime(value, "%Y-%m-%d")
+        return value
+    except ValueError:
+        raise ValidationError(MSG_DATE_YYYY_MM_DD)
+
+
+def validate_ids_list(ids: List[str]) -> List[str]:
+    if not ids:
+        raise ValidationError(MSG_AT_LEAST_ONE_ITEM_REQUIRED)
+    validated = []
+    for i, id_val in enumerate(ids, 1):
+        id_val = id_val.strip()
+        if not id_val:
+            raise ValidationError(MSG_ITEM_EMPTY)
+        if not UUID_PATTERN.match(id_val):
+            raise ValidationError(MSG_ITEM_INVALID_UUID)
+        validated.append(id_val)
+    return validated
+
+
+class LibraryClient:
+    def __init__(self, base_url: str = BASE_URL):
+        self.client = httpx.Client(base_url=base_url, timeout=30.0)
+
+    def close(self):
+        self.client.close()
+
+    def _handle_response(self, response: httpx.Response):
+        content_type = response.headers.get("content-type", "").lower()
+        if response.status_code >= 400:
+            message = response.text
+            try:
+                payload = response.json()
+                if isinstance(payload, dict):
+                    message = (
+                            payload.get("error", {}).get("message")
+                            or payload.get("message")
+                            or str(payload)
+                    )
+            except Exception:
+                message = response.text
+            raise RuntimeError(f"{response.status_code}: {message}")
+        if "application/json" in content_type:
+            payload = response.json()
+            if isinstance(payload, dict) and "successful" in payload:
+                if payload.get("successful"):
+                    return payload.get("data")
+                error = payload.get("error") or {}
+                raise RuntimeError(error.get("message") or str(payload))
+            return payload
+        return response
+
+    def get(self, path: str, **kwargs):
+        response = self.client.get(path, **kwargs)
+        return self._handle_response(response)
+
+    def post(self, path: str, **kwargs):
+        response = self.client.post(path, **kwargs)
+        return self._handle_response(response)
+
+    def patch(self, path: str, **kwargs):
+        response = self.client.patch(path, **kwargs)
+        return self._handle_response(response)
+
+    def delete(self, path: str, **kwargs):
+        response = self.client.delete(path, **kwargs)
+        return self._handle_response(response)
+
+    def list_books(self):
+        return self.get("/books/all")
+
+    def get_book(self, book_id: str):
+        return self.get(f"/books/{book_id}")
+
+    def book_exists(self, book_id: str) -> bool:
+        try:
+            self.get_book(book_id)
+            return True
+        except RuntimeError:
+            return False
+
+    def create_book(
+            self,
+            title: str,
+            author: str,
+            pages: int,
+            year: int,
+            genre: str,
+            status: str = "Available",
+    ):
+        payload = {
+            "title": title,
+            "author": author,
+            "pages": pages,
+            "year": year,
+            "genre": genre,
+            "status": status,
+        }
+        return self.post("/books/create", json=payload)
+
+    def update_book(
+            self,
+            book_id: str,
+            title: Optional[str] = None,
+            author: Optional[str] = None,
+            pages: Optional[int] = None,
+            year: Optional[int] = None,
+            genre: Optional[str] = None,
+            status: Optional[str] = None,
+    ):
+        payload = {
+            k: v
+            for k, v in {
+                "title": title,
+                "author": author,
+                "pages": pages,
+                "year": year,
+                "genre": genre,
+                "status": status,
+            }.items()
+            if v not in (None, "")
+        }
+        return self.patch(f"/books/{book_id}", json=payload)
+
+    def delete_book(self, book_id: str):
+        return self.delete(f"/books/{book_id}")
+
+    def borrow_books(
+            self, book_ids: List[str], visitor_id: str, worker_id: str, borrow_date: str
+    ):
+        payload = {
+            "bookIds": book_ids,
+            "visitorId": visitor_id,
+            "workerId": worker_id,
+            "borrowDate": borrow_date,
+        }
+        return self.post("/books/borrow", json=payload)
+
+    def return_books(
+            self, book_ids: List[str], visitor_id: str, worker_id: str, return_date: str
+    ):
+        payload = {
+            "bookIds": book_ids,
+            "visitorId": visitor_id,
+            "workerId": worker_id,
+            "returnDate": return_date,
+        }
+        return self.post("/books/return", json=payload)
+
+    def download_book(self, book_id: str) -> str:
+        response = self.get(f"/books/{book_id}/download")
+        return response.text if isinstance(response, httpx.Response) else str(response)
+
+    def list_visitors(self):
+        return self.get("/visitors/all")
+
+    def get_visitor(self, visitor_id: str):
+        return self.get(f"/visitors/{visitor_id}")
+
+    def visitor_exists(self, visitor_id: str) -> bool:
+        try:
+            self.get_visitor(visitor_id)
+            return True
+        except RuntimeError:
+            return False
+
+    def create_visitor(self, name: str, surname: str):
+        payload = {"name": name, "surname": surname}
+        return self.post("/visitors/create", json=payload)
+
+    def update_visitor(
+            self,
+            visitor_id: str,
+            name: Optional[str] = None,
+            surname: Optional[str] = None,
+    ):
+        payload = {k: v for k, v in {"name": name, "surname": surname}.items() if v}
+        return self.patch(f"/visitors/{visitor_id}", json=payload)
+
+    def delete_visitor(self, visitor_id: str):
+        return self.delete(f"/visitors/delete/{visitor_id}")
+
+    def download_visitor(self, visitor_id: str) -> str:
+        response = self.get(f"/visitors/{visitor_id}/download")
+        return response.text if isinstance(response, httpx.Response) else str(response)
+
+    def list_workers(self):
+        return self.get("/workers/all")
+
+    def get_worker(self, worker_id: str):
+        return self.get(f"/workers/{worker_id}")
+
+    def worker_exists(self, worker_id: str) -> bool:
+        try:
+            self.get_worker(worker_id)
+            return True
+        except RuntimeError:
+            return False
+
+    def create_worker(
+            self, name: str, surname: str, experience: int, work_days: List[str]
+    ):
+        payload = {
+            "name": name,
+            "surname": surname,
+            "experience": experience,
+            "workDays": work_days,
+        }
+        return self.post("/workers/create", json=payload)
+
+    def update_worker(
+            self,
+            worker_id: str,
+            name: Optional[str] = None,
+            surname: Optional[str] = None,
+            experience: Optional[int] = None,
+            work_days: Optional[List[str]] = None,
+    ):
+        payload = {
+            k: v
+            for k, v in {
+                "name": name,
+                "surname": surname,
+                "experience": experience,
+                "workDays": work_days,
+            }.items()
+            if v not in (None, "")
+        }
+        return self.patch(f"/workers/{worker_id}", json=payload)
+
+    def delete_worker(self, worker_id: str):
+        return self.delete(f"/workers/{worker_id}")
+
+    def workers_by_days(self, work_days: List[str]):
+        params = [("workDays", day) for day in work_days]
+        return self.get("/workers/by-work-days", params=params)
+
+    def download_worker(self, worker_id: str) -> str:
+        response = self.get(f"/workers/{worker_id}/download")
+        return response.text if isinstance(response, httpx.Response) else str(response)
+
+
+class MenuChoice(IntEnum):
+    LIST_BOOKS = 1
+    VIEW_BOOK = 2
+    CREATE_BOOK = 3
+    UPDATE_BOOK = 4
+    DELETE_BOOK = 5
+    BORROW_BOOKS = 6
+    RETURN_BOOKS = 7
+    DOWNLOAD_BOOK = 8
+    LIST_VISITORS = 9
+    VIEW_VISITOR = 10
+    CREATE_VISITOR = 11
+    UPDATE_VISITOR = 12
+    DELETE_VISITOR = 13
+    DOWNLOAD_VISITOR = 14
+    LIST_WORKERS = 15
+    VIEW_WORKER = 16
+    CREATE_WORKER = 17
+    UPDATE_WORKER = 18
+    DELETE_WORKER = 19
+    WORKERS_BY_DAYS = 20
+    DOWNLOAD_WORKER = 21
+    EXIT = 0
+
+
+MENU_TEXT = {
+    MenuChoice.LIST_BOOKS: "List books",
+    MenuChoice.VIEW_BOOK: "Get book by ID",
+    MenuChoice.CREATE_BOOK: "Create book",
+    MenuChoice.UPDATE_BOOK: "Update book",
+    MenuChoice.DELETE_BOOK: "Delete book",
+    MenuChoice.BORROW_BOOKS: "Borrow books",
+    MenuChoice.RETURN_BOOKS: "Return books",
+    MenuChoice.DOWNLOAD_BOOK: "Download book as file",
+    MenuChoice.LIST_VISITORS: "List visitors",
+    MenuChoice.VIEW_VISITOR: "Get visitor by ID",
+    MenuChoice.CREATE_VISITOR: "Create visitor",
+    MenuChoice.UPDATE_VISITOR: "Update visitor",
+    MenuChoice.DELETE_VISITOR: "Delete visitor",
+    MenuChoice.DOWNLOAD_VISITOR: "Download visitor as file",
+    MenuChoice.LIST_WORKERS: "List workers",
+    MenuChoice.VIEW_WORKER: "Get worker by ID",
+    MenuChoice.CREATE_WORKER: "Create worker",
+    MenuChoice.UPDATE_WORKER: "Update worker",
+    MenuChoice.DELETE_WORKER: "Delete worker",
+    MenuChoice.WORKERS_BY_DAYS: "Find workers by work days",
+    MenuChoice.DOWNLOAD_WORKER: "Download worker as file",
+    MenuChoice.EXIT: "Exit",
+}
+
+
+def prompt_with_validation(label: str, validator: Callable[[str], str]) -> str:
+    while True:
+        raw = input(label).strip()
+        try:
+            return validator(raw)
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_int_with_validation(label: str, validator: Callable[[int], int]) -> int:
+    while True:
+        raw = input(label).strip()
+        try:
+            value = int(raw)
+            return validator(value)
+        except ValueError:
+            print(MSG_ERROR_ENTER_VALID_INTEGER)
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_optional_with_validation(label: str, validator: Callable[[str], str]) -> Optional[str]:
+    while True:
+        raw = input(label).strip()
+        if not raw:
+            return None
+        try:
+            return validator(raw)
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_optional_int_with_validation(label: str, validator: Callable[[int], int]) -> Optional[int]:
+    while True:
+        raw = input(label).strip()
+        if not raw:
+            return None
+        try:
+            value = int(raw)
+            return validator(value)
+        except ValueError:
+            print(MSG_ERROR_ENTER_VALID_INTEGER)
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_choice(label: str, options: List[str]) -> str:
+    while True:
+        print(label)
+        for idx, option in enumerate(options, 1):
+            print(f"  {idx}. {option}")
+        raw = input(MSG_PICK_NUMBER).strip()
+        try:
+            selected = int(raw)
+            if 1 <= selected <= len(options):
+                return options[selected - 1]
+        except ValueError:
+            pass
+        print(MSG_ERROR_INVALID_CHOICE)
+
+
+def prompt_optional_choice(label: str, options: List[str]) -> Optional[str]:
+    while True:
+        print(label)
+        print("  0. Skip")
+        for idx, option in enumerate(options, 1):
+            print(f"  {idx}. {option}")
+        raw = input(MSG_PICK_NUMBER_SKIP).strip()
+        try:
+            selected = int(raw)
+            if selected == 0:
+                return None
+            if 1 <= selected <= len(options):
+                return options[selected - 1]
+        except ValueError:
+            pass
+        print(MSG_ERROR_INVALID_CHOICE)
+
+
+def prompt_multi_choice(label: str, options: List[str]) -> List[str]:
+    print(label)
+    print(MSG_USE_COMMA_OR_STAR)
+    for idx, option in enumerate(options, 1):
+        print(f"  {idx}. {option}")
+    while True:
+        raw = input(MSG_ENTER_NUMBERS_OR_NAMES).strip()
+        if raw == "*":
+            return options[:]
+        parts = [p.strip() for p in raw.split(",") if p.strip()]
+        result = []
+        valid = True
+        for p in parts:
+            if p in options:
+                result.append(p)
+            elif p.isdigit():
+                idx = int(p)
+                if 1 <= idx <= len(options):
+                    result.append(options[idx - 1])
+                else:
+                    print(MSG_ERROR_INVALID_NUMBER)
+                    valid = False
+                    break
+            else:
+                print(MSG_ERROR_INVALID_VALUE)
+                valid = False
+                break
+        if valid and result:
+            try:
+                return validate_work_days(result)
+            except ValidationError as e:
+                print(f"  Error: {e}")
+        elif valid and not result:
+            print(MSG_ERROR_AT_LEAST_ONE_VALUE)
+
+
+def prompt_optional_multi_choice(label: str, options: List[str]) -> Optional[List[str]]:
+    print(label)
+    print(MSG_USE_COMMA_STAR_OR_EMPTY)
+    for idx, option in enumerate(options, 1):
+        print(f"  {idx}. {option}")
+    while True:
+        raw = input(MSG_ENTER_NUMBERS_OR_NAMES_EMPTY_SKIP).strip()
+        if not raw:
+            return None
+        if raw == "*":
+            return options[:]
+        parts = [p.strip() for p in raw.split(",") if p.strip()]
+        result = []
+        valid = True
+        for p in parts:
+            if p in options:
+                result.append(p)
+            elif p.isdigit():
+                idx = int(p)
+                if 1 <= idx <= len(options):
+                    result.append(options[idx - 1])
+                else:
+                    print(MSG_ERROR_INVALID_NUMBER)
+                    valid = False
+                    break
+            else:
+                print(MSG_ERROR_INVALID_VALUE)
+                valid = False
+                break
+        if valid and result:
+            try:
+                return validate_work_days(result)
+            except ValidationError as e:
+                print(f"  Error: {e}")
+        elif valid and not result:
+            return None
+
+
+def prompt_book_ids(label: str, client: LibraryClient) -> List[str]:
+    while True:
+        raw = input(label).strip()
+        parts = [p.strip() for p in raw.split(",") if p.strip()]
+        try:
+            validated = validate_ids_list(parts)
+            for book_id in validated:
+                if not client.book_exists(book_id):
+                    print(MSG_ERROR_BOOK_NOT_FOUND)
+                    raise ValidationError("Book not found")
+            return validated
+        except ValidationError as e:
+            if "not found" not in str(e):
+                print(f"  Error: {e}")
+
+
+def prompt_book_id(label: str, client: LibraryClient, check_exists: bool = True) -> str:
+    while True:
+        raw = input(label).strip()
+        try:
+            validated = validate_uuid(raw, "Book ID")
+            if check_exists and not client.book_exists(validated):
+                print(MSG_ERROR_BOOK_NOT_FOUND_VALIDATED)
+                continue
+            return validated
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_visitor_id(label: str, client: LibraryClient, check_exists: bool = True) -> str:
+    while True:
+        raw = input(label).strip()
+        try:
+            validated = validate_uuid(raw, "Visitor ID")
+            if check_exists and not client.visitor_exists(validated):
+                print(MSG_ERROR_VISITOR_NOT_FOUND)
+                continue
+            return validated
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_worker_id(label: str, client: LibraryClient, check_exists: bool = True) -> str:
+    while True:
+        raw = input(label).strip()
+        try:
+            validated = validate_uuid(raw, "Worker ID")
+            if check_exists and not client.worker_exists(validated):
+                print(MSG_ERROR_WORKER_NOT_FOUND)
+                continue
+            return validated
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_date(label: str) -> str:
+    today = date.today().isoformat()
+    while True:
+        raw = input(f"{label} [{today}]: ").strip()
+        try:
+            return validate_date(raw)
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def print_books(books: Any):
+    if not books:
+        print(MSG_NO_BOOKS_FOUND)
+        return
+    for book in books:
+        print(SEPARATOR)
+        print(f"ID: {book.get('id')}")
+        print(f"Title: {book.get('title')}")
+        print(f"Author: {book.get('author')}")
+        print(f"Pages: {book.get('pages')}")
+        print(f"Year: {book.get('year')}")
+        print(f"Genre: {book.get('genre')}")
+        print(f"Status: {book.get('status')}")
+
+
+def print_visitors(visitors: Any):
+    if not visitors:
+        print(MSG_NO_VISITORS_FOUND)
+        return
+    for visitor in visitors:
+        print(SEPARATOR)
+        print(f"ID: {visitor.get('id')}")
+        print(f"Name: {visitor.get('name')} {visitor.get('surname')}")
+        print(f"Registered: {visitor.get('registrationDate')}")
+        current = visitor.get("currentBooks") or []
+        history = visitor.get("history") or []
+        print(f"Current books: {len(current)}")
+        print(f"History: {len(history)}")
+
+
+def print_workers(workers: Any):
+    if not workers:
+        print(MSG_NO_WORKERS_FOUND)
+        return
+    for worker in workers:
+        print(SEPARATOR)
+        print(f"ID: {worker.get('id')}")
+        print(f"Name: {worker.get('name')} {worker.get('surname')}")
+        print(f"Experience: {worker.get('experience')} years")
+        print(f"Work days: {', '.join(worker.get('workDays', []))}")
+        issued = worker.get("issuedBooks") or []
+        print(f"Issued books: {len(issued)}")
+
+
+def main_menu() -> Optional[MenuChoice]:
+    print("\n" + SEPARATOR)
+    for choice in MenuChoice:
+        print(f"{choice.value}. {MENU_TEXT[choice]}")
+    raw = input(PROMPT).strip()
+    try:
+        return MenuChoice(int(raw))
+    except Exception:
+        return None
+
+
+def handle_error(error: Exception):
+    print(f"{MSG_ERROR_PREFIX}{error}")
+
+
+def main():
+    client = LibraryClient()
+    try:
+        while True:
+            choice = main_menu()
+            if choice is None:
+                print(MSG_INVALID_OPTION)
+                continue
+            if choice == MenuChoice.EXIT:
+                print(MSG_GOODBYE)
+                break
+            try:
+                if choice == MenuChoice.LIST_BOOKS:
+                    print_books(client.list_books())
+
+                elif choice == MenuChoice.VIEW_BOOK:
+                    book_id = prompt_book_id(MSG_BOOK_ID_PROMPT, client)
+                    print_books([client.get_book(book_id)])
+
+                elif choice == MenuChoice.CREATE_BOOK:
+                    title = prompt_with_validation(MSG_TITLE_PROMPT, validate_title)
+                    author = prompt_with_validation(MSG_AUTHOR_PROMPT, validate_author)
+                    pages = prompt_int_with_validation(MSG_PAGES_PROMPT, validate_pages)
+                    year = prompt_int_with_validation(MSG_YEAR_PROMPT, validate_year)
+                    genre = prompt_choice(MSG_GENRE_PROMPT, GENRES)
+                    status = prompt_choice(MSG_STATUS_PROMPT, BOOK_STATUSES)
+                    print_books([client.create_book(title, author, pages, year, genre, status)])
+
+                elif choice == MenuChoice.UPDATE_BOOK:
+                    book_id = prompt_book_id(MSG_BOOK_ID_PROMPT, client)
+                    print(MSG_LEAVE_EMPTY_TO_SKIP)
+                    title = prompt_optional_with_validation(MSG_TITLE_SKIP_PROMPT, validate_title)
+                    author = prompt_optional_with_validation(MSG_AUTHOR_SKIP_PROMPT, validate_author)
+                    pages = prompt_optional_int_with_validation(MSG_PAGES_SKIP_PROMPT, validate_pages)
+                    year = prompt_optional_int_with_validation(MSG_YEAR_SKIP_PROMPT, validate_year)
+                    genre = prompt_optional_choice(MSG_GENRE_PROMPT, GENRES)
+                    status = prompt_optional_choice(MSG_STATUS_PROMPT, BOOK_STATUSES)
+                    if not any([title, author, pages, year, genre, status]):
+                        print(MSG_NO_FIELDS_TO_UPDATE)
+                        continue
+                    updated = client.update_book(book_id, title, author, pages, year, genre, status)
+                    print_books([updated])
+
+                elif choice == MenuChoice.DELETE_BOOK:
+                    book_id = prompt_book_id(MSG_BOOK_ID_PROMPT, client)
+                    result = client.delete_book(book_id)
+                    print(result.get("message") if isinstance(result, dict) else MSG_DELETED)
+
+                elif choice == MenuChoice.BORROW_BOOKS:
+                    book_ids = prompt_book_ids(MSG_BOOK_IDS_COMMA_SEPARATED, client)
+                    visitor_id = prompt_visitor_id(MSG_VISITOR_ID_PROMPT, client)
+                    worker_id = prompt_worker_id(MSG_WORKER_ID_PROMPT, client)
+                    borrow_date = prompt_date(MSG_BORROW_DATE_PROMPT)
+                    result = client.borrow_books(book_ids, visitor_id, worker_id, borrow_date)
+                    print(result.get("message") if isinstance(result, dict) else result)
+
+                elif choice == MenuChoice.RETURN_BOOKS:
+                    book_ids = prompt_book_ids(MSG_BOOK_IDS_COMMA_SEPARATED, client)
+                    visitor_id = prompt_visitor_id(MSG_VISITOR_ID_PROMPT, client)
+                    worker_id = prompt_worker_id(MSG_WORKER_ID_PROMPT, client)
+                    return_date = prompt_date(MSG_RETURN_DATE_PROMPT)
+                    result = client.return_books(book_ids, visitor_id, worker_id, return_date)
+                    print(result.get("message") if isinstance(result, dict) else result)
+
+                elif choice == MenuChoice.DOWNLOAD_BOOK:
+                    book_id = prompt_book_id(MSG_BOOK_ID_PROMPT, client)
+                    content = client.download_book(book_id)
+                    filepath = save_to_file("books", book_id, content)
+                    print(f"{MSG_FILE_SAVED_TO}{filepath}")
+
+                elif choice == MenuChoice.LIST_VISITORS:
+                    print_visitors(client.list_visitors())
+
+                elif choice == MenuChoice.VIEW_VISITOR:
+                    visitor_id = prompt_visitor_id(MSG_VISITOR_ID_PROMPT, client)
+                    visitor = client.get_visitor(visitor_id)
+                    print_visitors([visitor])
+                    current = visitor.get("currentBooks") or []
+                    history = visitor.get("history") or []
+                    if current:
+                        print(MSG_CURRENT_BOOKS)
+                        print_books(current)
+                    if history:
+                        print(MSG_HISTORY)
+                        print_books(history)
+
+                elif choice == MenuChoice.CREATE_VISITOR:
+                    name = prompt_with_validation(MSG_NAME_PROMPT, lambda v: validate_name(v, "Name"))
+                    surname = prompt_with_validation(MSG_SURNAME_PROMPT, lambda v: validate_name(v, "Surname"))
+                    print_visitors([client.create_visitor(name, surname)])
+
+                elif choice == MenuChoice.UPDATE_VISITOR:
+                    visitor_id = prompt_visitor_id(MSG_VISITOR_ID_PROMPT, client)
+                    print(MSG_LEAVE_EMPTY_TO_SKIP)
+                    name = prompt_optional_with_validation(MSG_NAME_PROMPT + " (empty to skip): ",
+                                                           lambda v: validate_name(v, "Name"))
+                    surname = prompt_optional_with_validation(MSG_SURNAME_PROMPT + " (empty to skip): ",
+                                                              lambda v: validate_name(v, "Surname"))
+                    if not name and not surname:
+                        print(MSG_NO_FIELDS_TO_UPDATE)
+                        continue
+                    visitor = client.update_visitor(visitor_id, name, surname)
+                    print_visitors([visitor])
+
+                elif choice == MenuChoice.DELETE_VISITOR:
+                    visitor_id = prompt_visitor_id(MSG_VISITOR_ID_PROMPT, client)
+                    client.delete_visitor(visitor_id)
+                    print(MSG_VISITOR_DELETED)
+
+                elif choice == MenuChoice.DOWNLOAD_VISITOR:
+                    visitor_id = prompt_visitor_id(MSG_VISITOR_ID_PROMPT, client)
+                    content = client.download_visitor(visitor_id)
+                    filepath = save_to_file("visitors", visitor_id, content)
+                    print(f"{MSG_FILE_SAVED_TO}{filepath}")
+
+                elif choice == MenuChoice.LIST_WORKERS:
+                    print_workers(client.list_workers())
+
+                elif choice == MenuChoice.VIEW_WORKER:
+                    worker_id = prompt_worker_id(MSG_WORKER_ID_PROMPT, client)
+                    worker = client.get_worker(worker_id)
+                    print_workers([worker])
+                    issued = worker.get("issuedBooks") or []
+                    if issued:
+                        print("\nIssued books:")
+                        print_books(issued)
+
+                elif choice == MenuChoice.CREATE_WORKER:
+                    name = prompt_with_validation(MSG_NAME_PROMPT, lambda v: validate_name(v, "Name"))
+                    surname = prompt_with_validation(MSG_SURNAME_PROMPT, lambda v: validate_name(v, "Surname"))
+                    experience = prompt_int_with_validation(MSG_EXPERIENCE_PROMPT, validate_experience)
+                    work_days = prompt_multi_choice(MSG_WORK_DAYS_PROMPT, WORK_DAYS)
+                    print_workers([client.create_worker(name, surname, experience, work_days)])
+
+                elif choice == MenuChoice.UPDATE_WORKER:
+                    worker_id = prompt_worker_id(MSG_WORKER_ID_PROMPT, client)
+                    print(MSG_LEAVE_EMPTY_TO_SKIP)
+                    name = prompt_optional_with_validation(MSG_NAME_PROMPT + " (empty to skip): ",
+                                                           lambda v: validate_name(v, "Name"))
+                    surname = prompt_optional_with_validation(MSG_SURNAME_PROMPT + " (empty to skip): ",
+                                                              lambda v: validate_name(v, "Surname"))
+                    experience = prompt_optional_int_with_validation(MSG_EXPERIENCE_PROMPT + " (empty to skip): ",
+                                                                     validate_experience)
+                    work_days = prompt_optional_multi_choice(MSG_WORK_DAYS_PROMPT, WORK_DAYS)
+                    if not any([name, surname, experience is not None, work_days]):
+                        print(MSG_NO_FIELDS_TO_UPDATE)
+                        continue
+                    worker = client.update_worker(worker_id, name, surname, experience, work_days)
+                    print_workers([worker])
+
+                elif choice == MenuChoice.DELETE_WORKER:
+                    worker_id = prompt_worker_id(MSG_WORKER_ID_PROMPT, client)
+                    client.delete_worker(worker_id)
+                    print(MSG_WORKER_DELETED)
+
+                elif choice == MenuChoice.WORKERS_BY_DAYS:
+                    work_days = prompt_multi_choice(MSG_SELECT_WORK_DAYS, WORK_DAYS)
+                    print_workers(client.workers_by_days(work_days))
+
+                elif choice == MenuChoice.DOWNLOAD_WORKER:
+                    worker_id = prompt_worker_id(MSG_WORKER_ID_PROMPT, client)
+                    content = client.download_worker(worker_id)
+                    filepath = save_to_file("workers", worker_id, content)
+                    print(f"{MSG_FILE_SAVED_TO}{filepath}")
+
+                else:
+                    print(MSG_INVALID_OPTION)
+
+            except (RuntimeError, httpx.HTTPError, ValueError) as error:
+                handle_error(error)
+    except KeyboardInterrupt:
+        print(MSG_INTERRUPTED_GOODBYE)
+    finally:
+        client.close()
+
+
+if __name__ == "__main__":
+    main()

data/messages.txt

@@ -1 +1,2 @@
-1da2f311-7fbb-4528-8710-c169bb8855d0|523f5745-ebde-4556-8e38-6a7ed95baf08|1|0cb6d70f-fd72-477f-863f-33b3f6932f90|2025-12-09T15:30:54.854152|SGVsbG8gd29ybGQ=
+47514c4b5247514c4a5247514c4752475150505247514b4f524951484747524b514b4c524b51484748524a5150505247514b4c5247514c495247514c4d524b5148474752484751504f5247514b505247514c4c5248514b4c524a514b5052484d514b50524b514b4f5248495148474852484f514b4f52484d5148494b5247514b4e52475148484d52475148484852475148484952475148474c524b5148484c52494b514c4a5247514847495247514c4e5247514847475247514c485249514b50524c514b4c524751504e52475148474852484d514c49524847514c49524a48515050524a4d514c4e524a4f514c48524848514b4c524a514b4f524849514c4c524a49514c49524c515050524849514b50524a4951504f52475148494b52484c5148494b52494b51484849524a4e5148484b52494c5148474c524b5148474c52494e51504e52475148484752494c5148484c52494b514b505248514c4c524951484748524b514c49524a49514b4c524a50514b50524a4d514c495249514c4d524a4e514b4c524a4e515050524951504e52484751484748524751504f524a4a514b5052484851484749524848514c4d524c514847485248505148494b524b4c514c475249514b4c52484c514c47524847514b505249514f4b52484c514b505247514c4f524e4c514c4f524848514c495247514b4d524d4e514b4f524a49514c4d5248495148494b5247514f505247514f4e5247514f49524751484949524a4e514c47524751484947524751484750524a4e514848475247514e4f52475148474e525048514f4e52475148474f52475148484a524751504752494f514d4d52475148484f524b514e48524847495148494952484748514f495248474a515047524c4f514d4d5248474d51504e525049514e4752484747515050524a5148484952504e51504f524a5148474f52484747514f505247514f4f5247514e4e52475148474a524847485150475248484b514c475248474b5148474e524b514c475247514d505248494851504752504e514f4952504b514f50525049514f505247514d48
+48364d4c3748364d4f37483651503748364d4e3748364c50374836494848374836515137483649484a3748364c4d374b364d4c374836494849374e364c4d3748364d4a374836514f374949364d4f375136514f37494d364d483751364d4f3749493651503748364d48374a36515137494c364d4e3749364d4a374d3649484a374836494a4c3748364c4f37483649494e37483649494937483649494a37483649484d374f3649494d374a4e364d493750364d4d374c364c50374d365150374949364c4d374b364d4e374d364d4b3751364d4a374a483651513748364d4b37495036494849374949364d4a3751365150374c49364d4b37494c36494849374d364d4d37494c364d48374a48364d4a374f36494a4c3748364c51374a4d364c4f374a5136514f37483649494c374a4f3649484d374f3649484d374d4b36494948374a4f3649494d374a4e364d48374a4836494849374a36494848374a364c503748364d4d3751364d4937494b364d4f374e4b364c4d37494b364d4b3749364948493751364d4e374949364d4b374c49364c4d374c50365150374c5036494848374c49364d4c374d49364d49374a483649484a374a4d364d48374d364d48374f49364c51374a48364c4d374d49364d4c374836504c374a48364d493748364d50374d49364d4b37504c364d4b374e4b364c4e374e4b364d4e374c49364d4d37505036494a4c37483651483748364d49374836504d3748364e49

data/participants.txt

@@ -1,7 +1,2 @@
-a4a2a13c-7aa3-4735-91c3-58a8c206a8ff|Maksim|Sh|string|2025-11-26T06:05:38.678099|5.0
-b7e14c6d-9048-4a7b-9420-48c0136ed913|DSIUfdh ihu|asdljfh|fasidjfosdiaj|2025-11-26T06:13:11.928647|10.0
-41dc9c33-fc1f-4f43-b640-4d7804ed8bfc|adf ihu|asdljfsadfh|asdf|2025-11-26T07:35:24.443778|9.4
-0cb6d70f-fd72-477f-863f-33b3f6932f90|Vika|Dryha|vikshalka|2025-12-02T22:13:16.858855|4.5
-b3692e4e-b9f2-4566-a123-af9cb9f2c9d0|фффф|ииииии|аааааа|2025-12-08T11:51:20.063434|0.0
-68c33585-b8b5-4567-b2b7-ff3fce1525af|asdf|asdf|asdf|2025-12-08T11:57:53.675948|3.0
-578dbd0e-c71f-42f6-83c1-7b506d468ff3|sadifsdaf|asdf|fasdfdsaf|2025-12-08T12:15:14.793116|3.4
+47514b505247514c4b5247514c4c5247514c4a52475148474852475150505247514c495247514c4e5247514b4c524a514c495248514b4f5250514c49524b514c4d524751504e525051504e524d514c4a52484b514b4c524c51504f5247514847475248514c49524751484749524e514c4d5247514b4f524c514c4c52485148494b5247514e4e52484b5148474e52475148484c52475148474c52475148475052475148494b5247514f4a52475148474b524751484948524a4751504e52475148484752475148484852475148484e52494f5148474e5249505148494b524751504f52475148484b524c5148484c52475148484d524a4e5148474e524a48514c4752494a514c47524b514b4c5248514c475250514b50524b514f4b524848514c4f5247514c475248514c4f524e514b505247514b4d524c4a514c4e524f514c4c5249514c4c524a48514c4a524c4d514b4f
+48364d483749364948493748364d4f374836494848374b364c503748364d4d3748364c4d3748364d493748364d4a374b364d4d374f364d4a3748364d4b3748364d4c374836494849374f364d4e37494c364d4b37494a364c4d374836514f3749365150374950364d48374c364d4b37494b364c513750364d4837483649484a374836494a4c3748364948513749503649484f37483649494d37483649484d374a4e36494a4c37483649494e37494c3649494d374b4936494a4c374a4c3649494f374c3649484c3749503649494d374a4c3649484d374a4d364d483748364c503749364d4b374f364c513749364c4d3748364c5137494b36504c3749364d493748364d50374c4b364d4b374c4e364d49374c4b364c4e3750364d4e374b364d4837494836494a4c3749364c4e3750363349

data/topics.txt

@@ -1,3 +1,2 @@
-3d67d49b-d2ad-4796-84ce-5765e636f71e|Hello|poaiujdfposaj poadsjjfdsaoifjop adsijfidosaj|2025-11-26T06:13:42.369699|a4a2a13c-7aa3-4735-91c3-58a8c206a8ff,b7e14c6d-9048-4a7b-9420-48c0136ed913|b7e14c6d-9048-4a7b-9420-48c0136ed913^SGk=;a4a2a13c-7aa3-4735-91c3-58a8c206a8ff^SGVsbG8=;a4a2a13c-7aa3-4735-91c3-58a8c206a8ff^VGhpcyBpcyBhIG5vcm1hbCB0ZXN0IG1lc3NhZ2U=;a4a2a13c-7aa3-4735-91c3-58a8c206a8ff^SGVsbG8gZnJvbSBjbGllbnQh;a4a2a13c-7aa3-4735-91c3-58a8c206a8ff^bHNsZGZob2lkc2F1aCBmb2lkc2F1aCBmb2lhc2R1aGZvaWQgc2F1aGZk
-5e497fa8-4983-497b-a2ef-e214181b1fc8|Hello|poaiujdfposaj poadsjjfdsaoifjop adsijfidosaj|2025-11-26T07:36:42.494103|a4a2a13c-7aa3-4735-91c3-58a8c206a8ff,b7e14c6d-9048-4a7b-9420-48c0136ed913|b7e14c6d-9048-4a7b-9420-48c0136ed913^SGk=;a4a2a13c-7aa3-4735-91c3-58a8c206a8ff^SGVsbG8=;41dc9c33-fc1f-4f43-b640-4d7804ed8bfc^TXkgbmFtZSBpcyBNYWtzaW0=;a4a2a13c-7aa3-4735-91c3-58a8c206a8ff^SGkgSGkgSGk=
-523f5745-ebde-4556-8e38-6a7ed95baf08|Maksim|sadfsadf|2025-12-08T11:58:03.296799||a4a2a13c-7aa3-4735-91c3-58a8c206a8ff^bHVpYXNoZmRhc2l1bGhmbHNhZA==;68c33585-b8b5-4567-b2b7-ff3fce1525af^dWFkaHNmaXVoc2FkIGl1Zmhhc2RpZmhkdXNhb2g=
+47514c4a5247514847495247514c4e5247514847475247514c485248514b505247514b4f5247514b4c524751504e5247514847485247514c4c5247514c49524f514c495249515050524e514b4c524a51484748524c514c49524f514c47524e514c4d524848514c4e524849514b4f52475150505247514c4d5247514b50524a51504f52475148494b5247514e495248475148474f52475148474f5247514848485247514a49524751484850524a475148484b5249505148474752494d5148484852475148474c524b5148484c5250514a49524a4d5148484852505148484c524b5148474952475148474d524a485148474c524b4751484747524a4d51484749524b4951504e52475148484c524a475148474c524b48514a49524b495148484c525051484747524b4f5148474d524951504e524b4e5148474752494d514c47524e514c475248514b4c52494b514c47524f514b505248514f4b52494b514b4f5247514c4f5247514c47524d4a514c4f524e514c495247514b4d524e514b4f52494a514b4f524848514c4d52494d5148494b
+48364d4937483649484a3748364d4d3748364d4e3748364c50374d3651503748364948493748364c4d3748365150374c364c503748364d4b3750364d4a3748364d483748365151374949364c4d3748364d4f374f364948493748364d4a3750365150374949364d4b374836514f374f364c50374b36514f37494b364d48374950365151374836494a4c3748364f4a374f36494850374836494850374836494949374a4e3649494d374a493649484837483649484d37483649484e374b4b3649494d374a4936494949374a4e364d48374d364d4837494d364c5137494b364c4d3748364c513748364d4c374836504c37494b364d493748364d50374c49364d4b374c4d364d4a374c49364c4e374950364d4a374b364d4e3749364c51374a4e36494a4c

unified_client.py

@@ -0,0 +1,1205 @@
+import json
+import re
+from datetime import date, datetime
+from enum import IntEnum
+from pathlib import Path
+from typing import Any, List, Optional, Callable
+from uuid import UUID
+
+import httpx
+
+FORUM_BASE_URL = "https://brestok-lab4.hf.space"
+LIBRARY_BASE_URL = "https://brestok-vika-server.hf.space"
+DOWNLOADS_DIR = Path(__file__).parent / "downloads"
+
+SEPARATOR = "=" * 70
+SEPARATOR_60 = "=" * 60
+SEPARATOR_90 = "-" * 90
+DASH_LINE_60 = "-" * 60
+PROMPT = "Select option: "
+
+TABLE_PARTICIPANTS = "participants"
+TABLE_TOPICS = "topics"
+
+GENRES = [
+    "Fiction", "Non-Fiction", "Mystery", "Sci-Fi", "Fantasy", "Biography",
+    "History", "Romance", "Thriller", "Horror", "Poetry", "Drama", "Comics", "Other",
+]
+
+BOOK_STATUSES = ["Available", "Borrowed"]
+
+WORK_DAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+
+NAME_PATTERN = re.compile(r"^[A-Za-zА-Яа-яЁёІіЇїЄєҐґ\s\-']+$")
+TITLE_PATTERN = re.compile(r"^[A-Za-zА-Яа-яЁёІіЇїЄєҐґ0-9\s\-'.,!?:;\"()]+$")
+UUID_PATTERN = re.compile(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
+
+
+class ValidationError(Exception):
+    pass
+
+
+def ensure_downloads_dir():
+    DOWNLOADS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def save_to_file(table: str, entity_id: str, content: str) -> str:
+    ensure_downloads_dir()
+    safe_id = entity_id.replace("/", "_").replace("\\", "_")
+    filename = f"{table}-{safe_id}.json"
+    filepath = DOWNLOADS_DIR / filename
+    if isinstance(content, (dict, list)):
+        text = json.dumps(content, ensure_ascii=False, indent=2)
+    else:
+        try:
+            parsed = json.loads(content)
+            text = json.dumps(parsed, ensure_ascii=False, indent=2)
+        except Exception:
+            text = content
+    filepath.write_text(text, encoding="utf-8")
+    return str(filepath)
+
+
+def validate_name(value: str, field_name: str = "Name") -> str:
+    value = value.strip()
+    if not value:
+        raise ValidationError(f"{field_name} is required.")
+    if len(value) < 2:
+        raise ValidationError(f"{field_name} must be at least 2 characters.")
+    if len(value) > 50:
+        raise ValidationError(f"{field_name} must be at most 50 characters.")
+    if not NAME_PATTERN.match(value):
+        raise ValidationError(f"{field_name} must contain only letters, spaces, hyphens, and apostrophes.")
+    return value
+
+
+def validate_title(value: str, field_name: str = "Title") -> str:
+    value = value.strip()
+    if not value:
+        raise ValidationError(f"{field_name} is required.")
+    if len(value) < 2:
+        raise ValidationError(f"{field_name} must be at least 2 characters.")
+    if len(value) > 100:
+        raise ValidationError(f"{field_name} must be at most 100 characters.")
+    if not TITLE_PATTERN.match(value):
+        raise ValidationError(f"{field_name} contains invalid characters.")
+    return value
+
+
+def validate_author(value: str) -> str:
+    value = value.strip()
+    if not value:
+        raise ValidationError("Author is required.")
+    if len(value) < 2:
+        raise ValidationError("Author must be at least 2 characters.")
+    if len(value) > 100:
+        raise ValidationError("Author must be at most 100 characters.")
+    if not NAME_PATTERN.match(value):
+        raise ValidationError("Author must contain only letters, spaces, hyphens, and apostrophes.")
+    return value
+
+
+def validate_pages(value: int) -> int:
+    if value < 1:
+        raise ValidationError("Pages must be at least 1.")
+    if value > 10000:
+        raise ValidationError("Pages must be at most 10000.")
+    return value
+
+
+def validate_year(value: int) -> int:
+    current_year = date.today().year
+    if value < 1000:
+        raise ValidationError("Year must be at least 1000.")
+    if value > current_year:
+        raise ValidationError(f"Year cannot be greater than {current_year}.")
+    return value
+
+
+def validate_genre(value: str) -> str:
+    if value not in GENRES:
+        raise ValidationError(f"Genre must be one of: {', '.join(GENRES)}")
+    return value
+
+
+def validate_status(value: str) -> str:
+    if value not in BOOK_STATUSES:
+        raise ValidationError(f"Status must be one of: {', '.join(BOOK_STATUSES)}")
+    return value
+
+
+def validate_experience(value: int) -> int:
+    if value < 0:
+        raise ValidationError("Experience cannot be negative.")
+    if value > 60:
+        raise ValidationError("Experience must be at most 60 years.")
+    return value
+
+
+def validate_work_days(days: List[str]) -> List[str]:
+    if not days:
+        raise ValidationError("At least one work day is required.")
+    invalid = [d for d in days if d not in WORK_DAYS]
+    if invalid:
+        raise ValidationError(f"Invalid work days: {', '.join(invalid)}. Valid options: {', '.join(WORK_DAYS)}")
+    return days
+
+
+def validate_uuid(value: str, field_name: str = "ID") -> str:
+    value = value.strip()
+    if not value:
+        raise ValidationError(f"{field_name} is required.")
+    if not UUID_PATTERN.match(value):
+        raise ValidationError(f"{field_name} must be a valid UUID format.")
+    return value
+
+
+def validate_date(value: str) -> str:
+    value = value.strip()
+    if not value:
+        return date.today().isoformat()
+    try:
+        datetime.strptime(value, "%Y-%m-%d")
+        return value
+    except ValueError:
+        raise ValidationError("Date must be in YYYY-MM-DD format.")
+
+
+def validate_ids_list(ids: List[str]) -> List[str]:
+    if not ids:
+        raise ValidationError("At least one item is required.")
+    validated = []
+    for i, id_val in enumerate(ids, 1):
+        id_val = id_val.strip()
+        if not id_val:
+            raise ValidationError(f"Item #{i} is empty.")
+        if not UUID_PATTERN.match(id_val):
+            raise ValidationError(f"Item #{i} ({id_val}) is not a valid UUID.")
+        validated.append(id_val)
+    return validated
+
+
+def validate_activity_rating(value: float) -> float:
+    if value < 0.1 or value > 5.0:
+        raise ValidationError("Activity rating must be between 0.1 and 5.0.")
+    return value
+
+
+class ForumClient:
+    def __init__(self, base_url: str = FORUM_BASE_URL):
+        self.base_url = base_url
+        self.client = httpx.Client(timeout=30.0)
+
+    @staticmethod
+    def _link(table: str, value: str) -> dict:
+        return {"table": table, "value": value}
+
+    def get_participants(self) -> list:
+        response = self.client.get(f"{self.base_url}/participants/")
+        response.raise_for_status()
+        return response.json()
+
+    def get_participant(self, participant_id: str) -> dict:
+        response = self.client.get(f"{self.base_url}/participants/{participant_id}")
+        response.raise_for_status()
+        return response.json()
+
+    def create_participant(self, first_name: str, last_name: str, nickname: str, activity_rating: float) -> dict:
+        payload = {
+            "first_name": first_name,
+            "last_name": last_name,
+            "nickname": nickname,
+            "activity_rating": activity_rating,
+        }
+        response = self.client.post(f"{self.base_url}/participants/", json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    def get_topics(self) -> list:
+        response = self.client.get(f"{self.base_url}/topics/")
+        response.raise_for_status()
+        return response.json()
+
+    def get_topic(self, topic_id: str) -> dict:
+        response = self.client.get(f"{self.base_url}/topics/{topic_id}")
+        response.raise_for_status()
+        return response.json()
+
+    def get_messages(self) -> list:
+        response = self.client.get(f"{self.base_url}/messages/")
+        response.raise_for_status()
+        return response.json()
+
+    def create_topic(self, title: str, description: str, participants: list = None) -> dict:
+        payload = {
+            "title": title,
+            "description": description,
+            "participants": [self._link(TABLE_PARTICIPANTS, p) for p in (participants or [])],
+            "messages": [],
+        }
+        response = self.client.post(f"{self.base_url}/topics/", json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    def publish_message(self, topic_id: str, participant_id: str, content: str) -> dict | str:
+        payload = {
+            "participant_id": self._link(TABLE_PARTICIPANTS, participant_id),
+            "content": content,
+        }
+        response = self.client.post(f"{self.base_url}/topics/{topic_id}/messages", json=payload)
+        if response.status_code == 400:
+            error_detail = response.json().get("detail", "Unknown error")
+            return f"ERROR: {error_detail}"
+        response.raise_for_status()
+        return response.json()
+
+    def download_participant(self, participant_id: str) -> dict:
+        response = self.client.get(f"{self.base_url}/participants/{participant_id}/download")
+        response.raise_for_status()
+        return response.json()
+
+    def download_topic(self, topic_id: str) -> dict:
+        response = self.client.get(f"{self.base_url}/topics/{topic_id}/download")
+        response.raise_for_status()
+        return response.json()
+
+    def download_message(self, message_id: str) -> dict:
+        response = self.client.get(f"{self.base_url}/messages/{message_id}/download")
+        response.raise_for_status()
+        return response.json()
+
+    def close(self):
+        self.client.close()
+
+
+class LibraryClient:
+    def __init__(self, base_url: str = LIBRARY_BASE_URL):
+        self.client = httpx.Client(base_url=base_url, timeout=30.0)
+
+    def close(self):
+        self.client.close()
+
+    def _handle_response(self, response: httpx.Response):
+        content_type = response.headers.get("content-type", "").lower()
+        if response.status_code >= 400:
+            message = response.text
+            try:
+                payload = response.json()
+                if isinstance(payload, dict):
+                    message = payload.get("error", {}).get("message") or payload.get("message") or str(payload)
+            except Exception:
+                message = response.text
+            raise RuntimeError(f"{response.status_code}: {message}")
+        if "application/json" in content_type:
+            payload = response.json()
+            if isinstance(payload, dict) and "successful" in payload:
+                if payload.get("successful"):
+                    return payload.get("data")
+                error = payload.get("error") or {}
+                raise RuntimeError(error.get("message") or str(payload))
+            return payload
+        return response
+
+    def get(self, path: str, **kwargs):
+        response = self.client.get(path, **kwargs)
+        return self._handle_response(response)
+
+    def post(self, path: str, **kwargs):
+        response = self.client.post(path, **kwargs)
+        return self._handle_response(response)
+
+    def patch(self, path: str, **kwargs):
+        response = self.client.patch(path, **kwargs)
+        return self._handle_response(response)
+
+    def delete(self, path: str, **kwargs):
+        response = self.client.delete(path, **kwargs)
+        return self._handle_response(response)
+
+    def list_books(self):
+        return self.get("/books/all")
+
+    def get_book(self, book_id: str):
+        return self.get(f"/books/{book_id}")
+
+    def book_exists(self, book_id: str) -> bool:
+        try:
+            self.get_book(book_id)
+            return True
+        except RuntimeError:
+            return False
+
+    def create_book(self, title: str, author: str, pages: int, year: int, genre: str, status: str = "Available"):
+        payload = {"title": title, "author": author, "pages": pages, "year": year, "genre": genre, "status": status}
+        return self.post("/books/create", json=payload)
+
+    def update_book(self, book_id: str, title: Optional[str] = None, author: Optional[str] = None,
+                    pages: Optional[int] = None, year: Optional[int] = None, genre: Optional[str] = None,
+                    status: Optional[str] = None):
+        payload = {k: v for k, v in {"title": title, "author": author, "pages": pages, "year": year,
+                                      "genre": genre, "status": status}.items() if v not in (None, "")}
+        return self.patch(f"/books/{book_id}", json=payload)
+
+    def delete_book(self, book_id: str):
+        return self.delete(f"/books/{book_id}")
+
+    def borrow_books(self, book_ids: List[str], visitor_id: str, worker_id: str, borrow_date: str):
+        payload = {"bookIds": book_ids, "visitorId": visitor_id, "workerId": worker_id, "borrowDate": borrow_date}
+        return self.post("/books/borrow", json=payload)
+
+    def return_books(self, book_ids: List[str], visitor_id: str, worker_id: str, return_date: str):
+        payload = {"bookIds": book_ids, "visitorId": visitor_id, "workerId": worker_id, "returnDate": return_date}
+        return self.post("/books/return", json=payload)
+
+    def download_book(self, book_id: str) -> str:
+        response = self.get(f"/books/{book_id}/download")
+        return response.text if isinstance(response, httpx.Response) else str(response)
+
+    def list_visitors(self):
+        return self.get("/visitors/all")
+
+    def get_visitor(self, visitor_id: str):
+        return self.get(f"/visitors/{visitor_id}")
+
+    def visitor_exists(self, visitor_id: str) -> bool:
+        try:
+            self.get_visitor(visitor_id)
+            return True
+        except RuntimeError:
+            return False
+
+    def create_visitor(self, name: str, surname: str):
+        payload = {"name": name, "surname": surname}
+        return self.post("/visitors/create", json=payload)
+
+    def update_visitor(self, visitor_id: str, name: Optional[str] = None, surname: Optional[str] = None):
+        payload = {k: v for k, v in {"name": name, "surname": surname}.items() if v}
+        return self.patch(f"/visitors/{visitor_id}", json=payload)
+
+    def delete_visitor(self, visitor_id: str):
+        return self.delete(f"/visitors/delete/{visitor_id}")
+
+    def download_visitor(self, visitor_id: str) -> str:
+        response = self.get(f"/visitors/{visitor_id}/download")
+        return response.text if isinstance(response, httpx.Response) else str(response)
+
+    def list_workers(self):
+        return self.get("/workers/all")
+
+    def get_worker(self, worker_id: str):
+        return self.get(f"/workers/{worker_id}")
+
+    def worker_exists(self, worker_id: str) -> bool:
+        try:
+            self.get_worker(worker_id)
+            return True
+        except RuntimeError:
+            return False
+
+    def create_worker(self, name: str, surname: str, experience: int, work_days: List[str]):
+        payload = {"name": name, "surname": surname, "experience": experience, "workDays": work_days}
+        return self.post("/workers/create", json=payload)
+
+    def update_worker(self, worker_id: str, name: Optional[str] = None, surname: Optional[str] = None,
+                      experience: Optional[int] = None, work_days: Optional[List[str]] = None):
+        payload = {k: v for k, v in {"name": name, "surname": surname, "experience": experience,
+                                      "workDays": work_days}.items() if v not in (None, "")}
+        return self.patch(f"/workers/{worker_id}", json=payload)
+
+    def delete_worker(self, worker_id: str):
+        return self.delete(f"/workers/{worker_id}")
+
+    def workers_by_days(self, work_days: List[str]):
+        params = [("workDays", day) for day in work_days]
+        return self.get("/workers/by-work-days", params=params)
+
+    def download_worker(self, worker_id: str) -> str:
+        response = self.get(f"/workers/{worker_id}/download")
+        return response.text if isinstance(response, httpx.Response) else str(response)
+
+
+class ForumMenuChoice(IntEnum):
+    LIST_PARTICIPANTS = 1
+    GET_PARTICIPANT = 2
+    CREATE_PARTICIPANT = 3
+    DOWNLOAD_PARTICIPANT = 4
+    LIST_TOPICS = 5
+    GET_TOPIC = 6
+    CREATE_TOPIC = 7
+    DOWNLOAD_TOPIC = 8
+    PUBLISH_MESSAGE = 9
+    LIST_MESSAGES = 10
+    DOWNLOAD_MESSAGE = 11
+    BACK = 0
+
+
+FORUM_MENU_TEXT = {
+    ForumMenuChoice.LIST_PARTICIPANTS: "List all participants",
+    ForumMenuChoice.GET_PARTICIPANT: "Get participant by ID",
+    ForumMenuChoice.CREATE_PARTICIPANT: "Create new participant",
+    ForumMenuChoice.DOWNLOAD_PARTICIPANT: "Download participant as file",
+    ForumMenuChoice.LIST_TOPICS: "List all topics",
+    ForumMenuChoice.GET_TOPIC: "Get topic by ID",
+    ForumMenuChoice.CREATE_TOPIC: "Create new topic",
+    ForumMenuChoice.DOWNLOAD_TOPIC: "Download topic as file",
+    ForumMenuChoice.PUBLISH_MESSAGE: "Publish message to topic",
+    ForumMenuChoice.LIST_MESSAGES: "List all messages",
+    ForumMenuChoice.DOWNLOAD_MESSAGE: "Download message as file",
+    ForumMenuChoice.BACK: "Back to server selection",
+}
+
+
+class LibraryMenuChoice(IntEnum):
+    LIST_BOOKS = 1
+    VIEW_BOOK = 2
+    CREATE_BOOK = 3
+    UPDATE_BOOK = 4
+    DELETE_BOOK = 5
+    BORROW_BOOKS = 6
+    RETURN_BOOKS = 7
+    DOWNLOAD_BOOK = 8
+    LIST_VISITORS = 9
+    VIEW_VISITOR = 10
+    CREATE_VISITOR = 11
+    UPDATE_VISITOR = 12
+    DELETE_VISITOR = 13
+    DOWNLOAD_VISITOR = 14
+    LIST_WORKERS = 15
+    VIEW_WORKER = 16
+    CREATE_WORKER = 17
+    UPDATE_WORKER = 18
+    DELETE_WORKER = 19
+    WORKERS_BY_DAYS = 20
+    DOWNLOAD_WORKER = 21
+    BACK = 0
+
+
+LIBRARY_MENU_TEXT = {
+    LibraryMenuChoice.LIST_BOOKS: "List books",
+    LibraryMenuChoice.VIEW_BOOK: "Get book by ID",
+    LibraryMenuChoice.CREATE_BOOK: "Create book",
+    LibraryMenuChoice.UPDATE_BOOK: "Update book",
+    LibraryMenuChoice.DELETE_BOOK: "Delete book",
+    LibraryMenuChoice.BORROW_BOOKS: "Borrow books",
+    LibraryMenuChoice.RETURN_BOOKS: "Return books",
+    LibraryMenuChoice.DOWNLOAD_BOOK: "Download book as file",
+    LibraryMenuChoice.LIST_VISITORS: "List visitors",
+    LibraryMenuChoice.VIEW_VISITOR: "Get visitor by ID",
+    LibraryMenuChoice.CREATE_VISITOR: "Create visitor",
+    LibraryMenuChoice.UPDATE_VISITOR: "Update visitor",
+    LibraryMenuChoice.DELETE_VISITOR: "Delete visitor",
+    LibraryMenuChoice.DOWNLOAD_VISITOR: "Download visitor as file",
+    LibraryMenuChoice.LIST_WORKERS: "List workers",
+    LibraryMenuChoice.VIEW_WORKER: "Get worker by ID",
+    LibraryMenuChoice.CREATE_WORKER: "Create worker",
+    LibraryMenuChoice.UPDATE_WORKER: "Update worker",
+    LibraryMenuChoice.DELETE_WORKER: "Delete worker",
+    LibraryMenuChoice.WORKERS_BY_DAYS: "Find workers by work days",
+    LibraryMenuChoice.DOWNLOAD_WORKER: "Download worker as file",
+    LibraryMenuChoice.BACK: "Back to server selection",
+}
+
+
+def prompt_with_validation(label: str, validator: Callable[[str], str]) -> str:
+    while True:
+        raw = input(label).strip()
+        try:
+            return validator(raw)
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_int_with_validation(label: str, validator: Callable[[int], int]) -> int:
+    while True:
+        raw = input(label).strip()
+        try:
+            value = int(raw)
+            return validator(value)
+        except ValueError:
+            print("  Error: Enter a valid integer.")
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_float_with_validation(label: str, validator: Callable[[float], float]) -> float:
+    while True:
+        raw = input(label).strip()
+        try:
+            value = float(raw)
+            return validator(value)
+        except ValueError:
+            print("  Error: Enter a valid number.")
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_optional_with_validation(label: str, validator: Callable[[str], str]) -> Optional[str]:
+    while True:
+        raw = input(label).strip()
+        if not raw:
+            return None
+        try:
+            return validator(raw)
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_optional_int_with_validation(label: str, validator: Callable[[int], int]) -> Optional[int]:
+    while True:
+        raw = input(label).strip()
+        if not raw:
+            return None
+        try:
+            value = int(raw)
+            return validator(value)
+        except ValueError:
+            print("  Error: Enter a valid integer.")
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_choice(label: str, options: List[str]) -> str:
+    while True:
+        print(label)
+        for idx, option in enumerate(options, 1):
+            print(f"  {idx}. {option}")
+        raw = input("Pick number: ").strip()
+        try:
+            selected = int(raw)
+            if 1 <= selected <= len(options):
+                return options[selected - 1]
+        except ValueError:
+            pass
+        print("  Error: Invalid choice.")
+
+
+def prompt_optional_choice(label: str, options: List[str]) -> Optional[str]:
+    while True:
+        print(label)
+        print("  0. Skip")
+        for idx, option in enumerate(options, 1):
+            print(f"  {idx}. {option}")
+        raw = input("Pick number (0 to skip): ").strip()
+        try:
+            selected = int(raw)
+            if selected == 0:
+                return None
+            if 1 <= selected <= len(options):
+                return options[selected - 1]
+        except ValueError:
+            pass
+        print("  Error: Invalid choice.")
+
+
+def prompt_multi_choice(label: str, options: List[str]) -> List[str]:
+    print(label)
+    print("Use comma to separate values or type * for all.")
+    for idx, option in enumerate(options, 1):
+        print(f"  {idx}. {option}")
+    while True:
+        raw = input("Enter numbers or names: ").strip()
+        if raw == "*":
+            return options[:]
+        parts = [p.strip() for p in raw.split(",") if p.strip()]
+        result = []
+        valid = True
+        for p in parts:
+            if p in options:
+                result.append(p)
+            elif p.isdigit():
+                idx = int(p)
+                if 1 <= idx <= len(options):
+                    result.append(options[idx - 1])
+                else:
+                    print(f"  Error: Invalid number {p}.")
+                    valid = False
+                    break
+            else:
+                print(f"  Error: Invalid value '{p}'.")
+                valid = False
+                break
+        if valid and result:
+            try:
+                return validate_work_days(result)
+            except ValidationError as e:
+                print(f"  Error: {e}")
+        elif valid and not result:
+            print("  Error: At least one value is required.")
+
+
+def prompt_optional_multi_choice(label: str, options: List[str]) -> Optional[List[str]]:
+    print(label)
+    print("Use comma to separate values, * for all, or leave empty to skip.")
+    for idx, option in enumerate(options, 1):
+        print(f"  {idx}. {option}")
+    while True:
+        raw = input("Enter numbers or names (empty to skip): ").strip()
+        if not raw:
+            return None
+        if raw == "*":
+            return options[:]
+        parts = [p.strip() for p in raw.split(",") if p.strip()]
+        result = []
+        valid = True
+        for p in parts:
+            if p in options:
+                result.append(p)
+            elif p.isdigit():
+                idx = int(p)
+                if 1 <= idx <= len(options):
+                    result.append(options[idx - 1])
+                else:
+                    print(f"  Error: Invalid number {p}.")
+                    valid = False
+                    break
+            else:
+                print(f"  Error: Invalid value '{p}'.")
+                valid = False
+                break
+        if valid and result:
+            try:
+                return validate_work_days(result)
+            except ValidationError as e:
+                print(f"  Error: {e}")
+        elif valid and not result:
+            return None
+
+
+def prompt_book_ids(label: str, client: LibraryClient) -> List[str]:
+    while True:
+        raw = input(label).strip()
+        parts = [p.strip() for p in raw.split(",") if p.strip()]
+        try:
+            validated = validate_ids_list(parts)
+            for book_id in validated:
+                if not client.book_exists(book_id):
+                    print(f"  Error: Book with ID {book_id} not found.")
+                    raise ValidationError("Book not found")
+            return validated
+        except ValidationError as e:
+            if "not found" not in str(e):
+                print(f"  Error: {e}")
+
+
+def prompt_book_id(label: str, client: LibraryClient, check_exists: bool = True) -> str:
+    while True:
+        raw = input(label).strip()
+        try:
+            validated = validate_uuid(raw, "Book ID")
+            if check_exists and not client.book_exists(validated):
+                print(f"  Error: Book with ID {validated} not found.")
+                continue
+            return validated
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_visitor_id(label: str, client: LibraryClient, check_exists: bool = True) -> str:
+    while True:
+        raw = input(label).strip()
+        try:
+            validated = validate_uuid(raw, "Visitor ID")
+            if check_exists and not client.visitor_exists(validated):
+                print(f"  Error: Visitor with ID {validated} not found.")
+                continue
+            return validated
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_worker_id(label: str, client: LibraryClient, check_exists: bool = True) -> str:
+    while True:
+        raw = input(label).strip()
+        try:
+            validated = validate_uuid(raw, "Worker ID")
+            if check_exists and not client.worker_exists(validated):
+                print(f"  Error: Worker with ID {validated} not found.")
+                continue
+            return validated
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def prompt_date(label: str) -> str:
+    today = date.today().isoformat()
+    while True:
+        raw = input(f"{label} [{today}]: ").strip()
+        try:
+            return validate_date(raw)
+        except ValidationError as e:
+            print(f"  Error: {e}")
+
+
+def print_books(books: Any):
+    if not books:
+        print("No books found.")
+        return
+    for book in books:
+        print(SEPARATOR)
+        print(f"ID: {book.get('id')}")
+        print(f"Title: {book.get('title')}")
+        print(f"Author: {book.get('author')}")
+        print(f"Pages: {book.get('pages')}")
+        print(f"Year: {book.get('year')}")
+        print(f"Genre: {book.get('genre')}")
+        print(f"Status: {book.get('status')}")
+
+
+def print_visitors(visitors: Any):
+    if not visitors:
+        print("No visitors found.")
+        return
+    for visitor in visitors:
+        print(SEPARATOR)
+        print(f"ID: {visitor.get('id')}")
+        print(f"Name: {visitor.get('name')} {visitor.get('surname')}")
+        print(f"Registered: {visitor.get('registrationDate')}")
+        current = visitor.get("currentBooks") or []
+        history = visitor.get("history") or []
+        print(f"Current books: {len(current)}")
+        print(f"History: {len(history)}")
+
+
+def print_workers(workers: Any):
+    if not workers:
+        print("No workers found.")
+        return
+    for worker in workers:
+        print(SEPARATOR)
+        print(f"ID: {worker.get('id')}")
+        print(f"Name: {worker.get('name')} {worker.get('surname')}")
+        print(f"Experience: {worker.get('experience')} years")
+        print(f"Work days: {', '.join(worker.get('workDays', []))}")
+        issued = worker.get("issuedBooks") or []
+        print(f"Issued books: {len(issued)}")
+
+
+def print_participants(participants: list):
+    if not participants:
+        print("No participants found.")
+        return
+    header = f"{'ID':<40} {'Name':<25} {'Nickname':<15} {'Rating':<10}"
+    print(header)
+    print(SEPARATOR_90)
+    for p in participants:
+        full_name = f"{p['first_name']} {p['last_name']}"
+        print(f"{p['id']:<40} {full_name:<25} {p['nickname']:<15} {p['activity_rating']:<10}")
+
+
+def print_topics(topics: list):
+    if not topics:
+        print("No topics found.")
+        return
+    for topic in topics:
+        print(f"\nTopic: {topic['title']}")
+        print(f"  ID: {topic['id']}")
+        print(f"  Description: {topic['description']}")
+        print(f"  Created: {topic['created_at']}")
+        print(f"  Messages ({len(topic['messages'])}):")
+        for msg in topic["messages"]:
+            print(f"    {msg.get('order_in_topic', 0)}. [{msg['participant_name']}]: {msg['content']}")
+
+
+def print_topic_detail(topic: dict):
+    print(f"\nTopic: {topic['title']}")
+    print(f"  ID: {topic['id']}")
+    print(f"  Description: {topic['description']}")
+    print(f"  Created: {topic['created_at']}")
+    print(f"  Participants: {len(topic['participants'])}")
+    print(f"\n  Messages ({len(topic['messages'])}):")
+    if not topic["messages"]:
+        print("    No messages yet.")
+    for msg in topic["messages"]:
+        print(f"    {msg.get('order_in_topic', 0)}. [{msg['participant_name']}]: {msg['content']}")
+
+
+def print_messages(messages: list):
+    if not messages:
+        print("    No messages yet.")
+        return
+    for msg in messages:
+        print(f"{msg['topic_title']} | #{msg['order_in_topic']} [{msg['participant_name']}]: {msg['content']}")
+
+
+def server_selection_menu() -> Optional[int]:
+    print("\n" + SEPARATOR)
+    print("           UNIFIED CLIENT - SERVER SELECTION")
+    print(SEPARATOR)
+    print("1. Forum Server (Topics, Participants, Messages)")
+    print("2. Library Server (Books, Visitors, Workers)")
+    print("0. Exit")
+    print(DASH_LINE_60)
+    raw = input(PROMPT).strip()
+    try:
+        choice = int(raw)
+        if choice in (0, 1, 2):
+            return choice
+    except ValueError:
+        pass
+    return None
+
+
+def forum_menu() -> Optional[ForumMenuChoice]:
+    print("\n" + SEPARATOR_60)
+    print("           FORUM CLIENT - MAIN MENU")
+    print(SEPARATOR_60)
+    for choice in ForumMenuChoice:
+        print(f"{choice.value}. {FORUM_MENU_TEXT[choice]}")
+    print(DASH_LINE_60)
+    raw = input(PROMPT).strip()
+    try:
+        return ForumMenuChoice(int(raw))
+    except Exception:
+        return None
+
+
+def library_menu() -> Optional[LibraryMenuChoice]:
+    print("\n" + SEPARATOR)
+    for choice in LibraryMenuChoice:
+        print(f"{choice.value}. {LIBRARY_MENU_TEXT[choice]}")
+    raw = input(PROMPT).strip()
+    try:
+        return LibraryMenuChoice(int(raw))
+    except Exception:
+        return None
+
+
+def run_forum_client():
+    client = ForumClient()
+    try:
+        while True:
+            choice = forum_menu()
+            if choice is None:
+                print("Invalid option. Please try again.")
+                continue
+            if choice == ForumMenuChoice.BACK:
+                break
+
+            try:
+                if choice == ForumMenuChoice.LIST_PARTICIPANTS:
+                    print(SEPARATOR_60)
+                    print("ALL PARTICIPANTS:")
+                    print_participants(client.get_participants())
+
+                elif choice == ForumMenuChoice.GET_PARTICIPANT:
+                    print(SEPARATOR_60)
+                    participant_id = input("Enter participant ID: ").strip()
+                    try:
+                        UUID(participant_id)
+                        participant = client.get_participant(participant_id)
+                        print(f"\nParticipant: {participant['first_name']} {participant['last_name']}")
+                        print(f"  ID: {participant['id']}")
+                        print(f"  Nickname: {participant['nickname']}")
+                        print(f"  Rating: {participant['activity_rating']}")
+                        print(f"  Registered: {participant['registered_at']}")
+                    except ValueError:
+                        print("Invalid UUID format.")
+
+                elif choice == ForumMenuChoice.CREATE_PARTICIPANT:
+                    print(SEPARATOR_60)
+                    print("CREATE NEW PARTICIPANT:")
+                    first_name = prompt_with_validation("  First name: ",
+                        lambda v: v if re.fullmatch(r"[A-Za-zА-Яа-яЁё-]+", v) else (_ for _ in ()).throw(
+                            ValidationError("First name must contain only letters and '-'.")))
+                    last_name = prompt_with_validation("  Last name: ",
+                        lambda v: v if re.fullmatch(r"[A-Za-zА-Яа-яЁё-]+", v) else (_ for _ in ()).throw(
+                            ValidationError("Last name must contain only letters and '-'.")))
+                    nickname = prompt_with_validation("  Nickname: ",
+                        lambda v: v if re.fullmatch(r"[A-Za-zА-Яа-яЁё-]+", v) else (_ for _ in ()).throw(
+                            ValidationError("Nickname must contain only letters and '-'.")))
+                    activity_rating = prompt_float_with_validation("  Activity rating: ", validate_activity_rating)
+                    participant = client.create_participant(first_name, last_name, nickname, activity_rating)
+                    print("\nParticipant created successfully!")
+                    print(f"  ID: {participant['id']}")
+
+                elif choice == ForumMenuChoice.LIST_TOPICS:
+                    print(SEPARATOR_60)
+                    print("ALL TOPICS:")
+                    print_topics(client.get_topics())
+
+                elif choice == ForumMenuChoice.GET_TOPIC:
+                    print(SEPARATOR_60)
+                    topic_id = input("Enter topic ID: ").strip()
+                    try:
+                        UUID(topic_id)
+                        topic = client.get_topic(topic_id)
+                        print_topic_detail(topic)
+                    except ValueError:
+                        print("Invalid UUID format.")
+
+                elif choice == ForumMenuChoice.CREATE_TOPIC:
+                    print(SEPARATOR_60)
+                    print("CREATE NEW TOPIC:")
+                    title = input("  Title: ").strip()
+                    description = input("  Description: ").strip()
+                    topic = client.create_topic(title, description)
+                    print("\nTopic created successfully!")
+                    print(f"  ID: {topic['id']}")
+
+                elif choice == ForumMenuChoice.PUBLISH_MESSAGE:
+                    print(SEPARATOR_60)
+                    print("PUBLISH MESSAGE TO TOPIC:")
+                    while True:
+                        topic_id = input("  Topic ID: ").strip()
+                        if not topic_id:
+                            print("Topic ID is required.")
+                            continue
+                        try:
+                            client.get_topic(topic_id)
+                            break
+                        except httpx.HTTPStatusError as e:
+                            if e.response.status_code in (404, 422):
+                                print("Topic not found.")
+                            else:
+                                print(f"Error: {e.response.status_code} - {e.response.text}")
+
+                    while True:
+                        participant_id = input("  Participant ID: ").strip()
+                        if not participant_id:
+                            print("Participant ID is required.")
+                            continue
+                        try:
+                            client.get_participant(participant_id)
+                            break
+                        except httpx.HTTPStatusError as e:
+                            if e.response.status_code in (404, 422):
+                                print("Participant not found.")
+                            else:
+                                print(f"Error: {e.response.status_code} - {e.response.text}")
+
+                    content = input("  Message content: ").strip()
+                    result = client.publish_message(topic_id, participant_id, content)
+                    if isinstance(result, str):
+                        print(f"\n{result}")
+                    else:
+                        print("\nMessage published successfully!")
+                        print(f"Topic now has {len(result['messages'])} message(s).")
+
+                elif choice == ForumMenuChoice.LIST_MESSAGES:
+                    print(SEPARATOR_60)
+                    print("ALL MESSAGES:")
+                    print_messages(client.get_messages())
+
+                elif choice == ForumMenuChoice.DOWNLOAD_PARTICIPANT:
+                    print(SEPARATOR_60)
+                    participant_id = input("Enter participant ID: ").strip()
+                    try:
+                        UUID(participant_id)
+                        content = client.download_participant(participant_id)
+                        filepath = save_to_file("participants", participant_id, content)
+                        print(f"File saved to: {filepath}")
+                    except ValueError:
+                        print("Invalid UUID format.")
+
+                elif choice == ForumMenuChoice.DOWNLOAD_TOPIC:
+                    print(SEPARATOR_60)
+                    topic_id = input("Enter topic ID: ").strip()
+                    try:
+                        UUID(topic_id)
+                        content = client.download_topic(topic_id)
+                        filepath = save_to_file("topics", topic_id, content)
+                        print(f"File saved to: {filepath}")
+                    except ValueError:
+                        print("Invalid UUID format.")
+
+                elif choice == ForumMenuChoice.DOWNLOAD_MESSAGE:
+                    print(SEPARATOR_60)
+                    message_id = input("Enter message ID: ").strip()
+                    try:
+                        UUID(message_id)
+                        content = client.download_message(message_id)
+                        filepath = save_to_file("messages", message_id, content)
+                        print(f"File saved to: {filepath}")
+                    except ValueError:
+                        print("Invalid UUID format.")
+
+            except httpx.HTTPStatusError as e:
+                print(f"Error: {e.response.status_code} - {e.response.text}")
+    finally:
+        client.close()
+
+
+def run_library_client():
+    client = LibraryClient()
+    try:
+        while True:
+            choice = library_menu()
+            if choice is None:
+                print("Invalid option.")
+                continue
+            if choice == LibraryMenuChoice.BACK:
+                break
+
+            try:
+                if choice == LibraryMenuChoice.LIST_BOOKS:
+                    print_books(client.list_books())
+
+                elif choice == LibraryMenuChoice.VIEW_BOOK:
+                    book_id = prompt_book_id("Book ID: ", client)
+                    print_books([client.get_book(book_id)])
+
+                elif choice == LibraryMenuChoice.CREATE_BOOK:
+                    title = prompt_with_validation("Title: ", validate_title)
+                    author = prompt_with_validation("Author: ", validate_author)
+                    pages = prompt_int_with_validation("Pages: ", validate_pages)
+                    year = prompt_int_with_validation("Year: ", validate_year)
+                    genre = prompt_choice("Genre:", GENRES)
+                    status = prompt_choice("Status:", BOOK_STATUSES)
+                    print_books([client.create_book(title, author, pages, year, genre, status)])
+
+                elif choice == LibraryMenuChoice.UPDATE_BOOK:
+                    book_id = prompt_book_id("Book ID: ", client)
+                    print("Leave fields empty to skip them.")
+                    title = prompt_optional_with_validation("Title (empty to skip): ", validate_title)
+                    author = prompt_optional_with_validation("Author (empty to skip): ", validate_author)
+                    pages = prompt_optional_int_with_validation("Pages (empty to skip): ", validate_pages)
+                    year = prompt_optional_int_with_validation("Year (empty to skip): ", validate_year)
+                    genre = prompt_optional_choice("Genre:", GENRES)
+                    status = prompt_optional_choice("Status:", BOOK_STATUSES)
+                    if not any([title, author, pages, year, genre, status]):
+                        print("No fields to update.")
+                        continue
+                    print_books([client.update_book(book_id, title, author, pages, year, genre, status)])
+
+                elif choice == LibraryMenuChoice.DELETE_BOOK:
+                    book_id = prompt_book_id("Book ID: ", client)
+                    result = client.delete_book(book_id)
+                    print(result.get("message") if isinstance(result, dict) else "Deleted.")
+
+                elif choice == LibraryMenuChoice.BORROW_BOOKS:
+                    book_ids = prompt_book_ids("Book IDs (comma separated): ", client)
+                    visitor_id = prompt_visitor_id("Visitor ID: ", client)
+                    worker_id = prompt_worker_id("Worker ID: ", client)
+                    borrow_date = prompt_date("Borrow date (YYYY-MM-DD)")
+                    result = client.borrow_books(book_ids, visitor_id, worker_id, borrow_date)
+                    print(result.get("message") if isinstance(result, dict) else result)
+
+                elif choice == LibraryMenuChoice.RETURN_BOOKS:
+                    book_ids = prompt_book_ids("Book IDs (comma separated): ", client)
+                    visitor_id = prompt_visitor_id("Visitor ID: ", client)
+                    worker_id = prompt_worker_id("Worker ID: ", client)
+                    return_date = prompt_date("Return date (YYYY-MM-DD)")
+                    result = client.return_books(book_ids, visitor_id, worker_id, return_date)
+                    print(result.get("message") if isinstance(result, dict) else result)
+
+                elif choice == LibraryMenuChoice.DOWNLOAD_BOOK:
+                    book_id = prompt_book_id("Book ID: ", client)
+                    content = client.download_book(book_id)
+                    filepath = save_to_file("books", book_id, content)
+                    print(f"File saved to: {filepath}")
+
+                elif choice == LibraryMenuChoice.LIST_VISITORS:
+                    print_visitors(client.list_visitors())
+
+                elif choice == LibraryMenuChoice.VIEW_VISITOR:
+                    visitor_id = prompt_visitor_id("Visitor ID: ", client)
+                    visitor = client.get_visitor(visitor_id)
+                    print_visitors([visitor])
+                    current = visitor.get("currentBooks") or []
+                    history = visitor.get("history") or []
+                    if current:
+                        print("\nCurrent books:")
+                        print_books(current)
+                    if history:
+                        print("\nHistory:")
+                        print_books(history)
+
+                elif choice == LibraryMenuChoice.CREATE_VISITOR:
+                    name = prompt_with_validation("Name: ", lambda v: validate_name(v, "Name"))
+                    surname = prompt_with_validation("Surname: ", lambda v: validate_name(v, "Surname"))
+                    print_visitors([client.create_visitor(name, surname)])
+
+                elif choice == LibraryMenuChoice.UPDATE_VISITOR:
+                    visitor_id = prompt_visitor_id("Visitor ID: ", client)
+                    print("Leave fields empty to skip them.")
+                    name = prompt_optional_with_validation("Name (empty to skip): ", lambda v: validate_name(v, "Name"))
+                    surname = prompt_optional_with_validation("Surname (empty to skip): ", lambda v: validate_name(v, "Surname"))
+                    if not name and not surname:
+                        print("No fields to update.")
+                        continue
+                    print_visitors([client.update_visitor(visitor_id, name, surname)])
+
+                elif choice == LibraryMenuChoice.DELETE_VISITOR:
+                    visitor_id = prompt_visitor_id("Visitor ID: ", client)
+                    client.delete_visitor(visitor_id)
+                    print("Visitor deleted.")
+
+                elif choice == LibraryMenuChoice.DOWNLOAD_VISITOR:
+                    visitor_id = prompt_visitor_id("Visitor ID: ", client)
+                    content = client.download_visitor(visitor_id)
+                    filepath = save_to_file("visitors", visitor_id, content)
+                    print(f"File saved to: {filepath}")
+
+                elif choice == LibraryMenuChoice.LIST_WORKERS:
+                    print_workers(client.list_workers())
+
+                elif choice == LibraryMenuChoice.VIEW_WORKER:
+                    worker_id = prompt_worker_id("Worker ID: ", client)
+                    worker = client.get_worker(worker_id)
+                    print_workers([worker])
+                    issued = worker.get("issuedBooks") or []
+                    if issued:
+                        print("\nIssued books:")
+                        print_books(issued)
+
+                elif choice == LibraryMenuChoice.CREATE_WORKER:
+                    name = prompt_with_validation("Name: ", lambda v: validate_name(v, "Name"))
+                    surname = prompt_with_validation("Surname: ", lambda v: validate_name(v, "Surname"))
+                    experience = prompt_int_with_validation("Experience (years): ", validate_experience)
+                    work_days = prompt_multi_choice("Work days:", WORK_DAYS)
+                    print_workers([client.create_worker(name, surname, experience, work_days)])
+
+                elif choice == LibraryMenuChoice.UPDATE_WORKER:
+                    worker_id = prompt_worker_id("Worker ID: ", client)
+                    print("Leave fields empty to skip them.")
+                    name = prompt_optional_with_validation("Name (empty to skip): ", lambda v: validate_name(v, "Name"))
+                    surname = prompt_optional_with_validation("Surname (empty to skip): ", lambda v: validate_name(v, "Surname"))
+                    experience = prompt_optional_int_with_validation("Experience (empty to skip): ", validate_experience)
+                    work_days = prompt_optional_multi_choice("Work days:", WORK_DAYS)
+                    if not any([name, surname, experience is not None, work_days]):
+                        print("No fields to update.")
+                        continue
+                    print_workers([client.update_worker(worker_id, name, surname, experience, work_days)])
+
+                elif choice == LibraryMenuChoice.DELETE_WORKER:
+                    worker_id = prompt_worker_id("Worker ID: ", client)
+                    client.delete_worker(worker_id)
+                    print("Worker deleted.")
+
+                elif choice == LibraryMenuChoice.WORKERS_BY_DAYS:
+                    work_days = prompt_multi_choice("Select work days:", WORK_DAYS)
+                    print_workers(client.workers_by_days(work_days))
+
+                elif choice == LibraryMenuChoice.DOWNLOAD_WORKER:
+                    worker_id = prompt_worker_id("Worker ID: ", client)
+                    content = client.download_worker(worker_id)
+                    filepath = save_to_file("workers", worker_id, content)
+                    print(f"File saved to: {filepath}")
+
+            except (RuntimeError, httpx.HTTPError, ValueError) as error:
+                print(f"Error: {error}")
+    finally:
+        client.close()
+
+
+def main():
+    try:
+        while True:
+            server_choice = server_selection_menu()
+            if server_choice is None:
+                print("Invalid option. Please try again.")
+                continue
+            if server_choice == 0:
+                print("Goodbye!")
+                break
+            elif server_choice == 1:
+                run_forum_client()
+            elif server_choice == 2:
+                run_library_client()
+    except KeyboardInterrupt:
+        print("\nInterrupted. Goodbye!")
+
+
+if __name__ == "__main__":
+    main()
+