init

.gitignore

@@ -0,0 +1 @@
+.env

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,169 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="DuplicatedCode" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <Languages>
+        <language minSize="74" name="Python" />
+      </Languages>
+    </inspection_tool>
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="143">
+            <item index="0" class="java.lang.String" itemvalue="motor" />
+            <item index="1" class="java.lang.String" itemvalue="rsa" />
+            <item index="2" class="java.lang.String" itemvalue="pybit" />
+            <item index="3" class="java.lang.String" itemvalue="PyYAML" />
+            <item index="4" class="java.lang.String" itemvalue="cffi" />
+            <item index="5" class="java.lang.String" itemvalue="marshmallow" />
+            <item index="6" class="java.lang.String" itemvalue="pyasn1" />
+            <item index="7" class="java.lang.String" itemvalue="requests" />
+            <item index="8" class="java.lang.String" itemvalue="exceptiongroup" />
+            <item index="9" class="java.lang.String" itemvalue="starlette" />
+            <item index="10" class="java.lang.String" itemvalue="certifi" />
+            <item index="11" class="java.lang.String" itemvalue="anyio" />
+            <item index="12" class="java.lang.String" itemvalue="urllib3" />
+            <item index="13" class="java.lang.String" itemvalue="uvicorn" />
+            <item index="14" class="java.lang.String" itemvalue="python-jose" />
+            <item index="15" class="java.lang.String" itemvalue="uvloop" />
+            <item index="16" class="java.lang.String" itemvalue="passlib" />
+            <item index="17" class="java.lang.String" itemvalue="websockets" />
+            <item index="18" class="java.lang.String" itemvalue="annotated-types" />
+            <item index="19" class="java.lang.String" itemvalue="watchfiles" />
+            <item index="20" class="java.lang.String" itemvalue="dnspython" />
+            <item index="21" class="java.lang.String" itemvalue="pydantic" />
+            <item index="22" class="java.lang.String" itemvalue="pymongo" />
+            <item index="23" class="java.lang.String" itemvalue="ecdsa" />
+            <item index="24" class="java.lang.String" itemvalue="packaging" />
+            <item index="25" class="java.lang.String" itemvalue="starkbank-ecdsa" />
+            <item index="26" class="java.lang.String" itemvalue="pydash" />
+            <item index="27" class="java.lang.String" itemvalue="bcrypt" />
+            <item index="28" class="java.lang.String" itemvalue="fastapi" />
+            <item index="29" class="java.lang.String" itemvalue="pydantic_core" />
+            <item index="30" class="java.lang.String" itemvalue="python-http-client" />
+            <item index="31" class="java.lang.String" itemvalue="email_validator" />
+            <item index="32" class="java.lang.String" itemvalue="typing_extensions" />
+            <item index="33" class="java.lang.String" itemvalue="pycryptodome" />
+            <item index="34" class="java.lang.String" itemvalue="pyee" />
+            <item index="35" class="java.lang.String" itemvalue="azure-identity" />
+            <item index="36" class="java.lang.String" itemvalue="greenlet" />
+            <item index="37" class="java.lang.String" itemvalue="playwright" />
+            <item index="38" class="java.lang.String" itemvalue="pyppeteer" />
+            <item index="39" class="java.lang.String" itemvalue="SQLAlchemy" />
+            <item index="40" class="java.lang.String" itemvalue="pyarrow" />
+            <item index="41" class="java.lang.String" itemvalue="protobuf" />
+            <item index="42" class="java.lang.String" itemvalue="tornado" />
+            <item index="43" class="java.lang.String" itemvalue="solders" />
+            <item index="44" class="java.lang.String" itemvalue="rich" />
+            <item index="45" class="java.lang.String" itemvalue="numpy" />
+            <item index="46" class="java.lang.String" itemvalue="Jinja2" />
+            <item index="47" class="java.lang.String" itemvalue="DateTime" />
+            <item index="48" class="java.lang.String" itemvalue="attrs" />
+            <item index="49" class="java.lang.String" itemvalue="altair" />
+            <item index="50" class="java.lang.String" itemvalue="pandas" />
+            <item index="51" class="java.lang.String" itemvalue="Pygments" />
+            <item index="52" class="java.lang.String" itemvalue="pip" />
+            <item index="53" class="java.lang.String" itemvalue="pillow" />
+            <item index="54" class="java.lang.String" itemvalue="httpx" />
+            <item index="55" class="java.lang.String" itemvalue="boto3" />
+            <item index="56" class="java.lang.String" itemvalue="six" />
+            <item index="57" class="java.lang.String" itemvalue="botocore" />
+            <item index="58" class="java.lang.String" itemvalue="huggingface-hub" />
+            <item index="59" class="java.lang.String" itemvalue="nvidia-cuda-cupti-cu12" />
+            <item index="60" class="java.lang.String" itemvalue="nvidia-cufft-cu12" />
+            <item index="61" class="java.lang.String" itemvalue="python-dateutil" />
+            <item index="62" class="java.lang.String" itemvalue="python-dotenv" />
+            <item index="63" class="java.lang.String" itemvalue="MarkupSafe" />
+            <item index="64" class="java.lang.String" itemvalue="pycparser" />
+            <item index="65" class="java.lang.String" itemvalue="frozenlist" />
+            <item index="66" class="java.lang.String" itemvalue="fsspec" />
+            <item index="67" class="java.lang.String" itemvalue="nvidia-cusolver-cu12" />
+            <item index="68" class="java.lang.String" itemvalue="nvidia-curand-cu12" />
+            <item index="69" class="java.lang.String" itemvalue="filelock" />
+            <item index="70" class="java.lang.String" itemvalue="safetensors" />
+            <item index="71" class="java.lang.String" itemvalue="sentencepiece" />
+            <item index="72" class="java.lang.String" itemvalue="multiprocess" />
+            <item index="73" class="java.lang.String" itemvalue="pyarrow-hotfix" />
+            <item index="74" class="java.lang.String" itemvalue="nvidia-cuda-runtime-cu12" />
+            <item index="75" class="java.lang.String" itemvalue="sympy" />
+            <item index="76" class="java.lang.String" itemvalue="xxhash" />
+            <item index="77" class="java.lang.String" itemvalue="beautifulsoup4" />
+            <item index="78" class="java.lang.String" itemvalue="tokenizers" />
+            <item index="79" class="java.lang.String" itemvalue="nvidia-cuda-nvrtc-cu12" />
+            <item index="80" class="java.lang.String" itemvalue="transformers" />
+            <item index="81" class="java.lang.String" itemvalue="triton" />
+            <item index="82" class="java.lang.String" itemvalue="cryptography" />
+            <item index="83" class="java.lang.String" itemvalue="openai" />
+            <item index="84" class="java.lang.String" itemvalue="nvidia-cublas-cu12" />
+            <item index="85" class="java.lang.String" itemvalue="regex" />
+            <item index="86" class="java.lang.String" itemvalue="nvidia-nvtx-cu12" />
+            <item index="87" class="java.lang.String" itemvalue="PyMySQL" />
+            <item index="88" class="java.lang.String" itemvalue="Mako" />
+            <item index="89" class="java.lang.String" itemvalue="evaluate" />
+            <item index="90" class="java.lang.String" itemvalue="httpcore" />
+            <item index="91" class="java.lang.String" itemvalue="idna" />
+            <item index="92" class="java.lang.String" itemvalue="environs" />
+            <item index="93" class="java.lang.String" itemvalue="networkx" />
+            <item index="94" class="java.lang.String" itemvalue="nvidia-nvjitlink-cu12" />
+            <item index="95" class="java.lang.String" itemvalue="nvidia-cusparse-cu12" />
+            <item index="96" class="java.lang.String" itemvalue="datasets" />
+            <item index="97" class="java.lang.String" itemvalue="nvidia-nccl-cu12" />
+            <item index="98" class="java.lang.String" itemvalue="sniffio" />
+            <item index="99" class="java.lang.String" itemvalue="aiomysql" />
+            <item index="100" class="java.lang.String" itemvalue="sqladmin" />
+            <item index="101" class="java.lang.String" itemvalue="itsdangerous" />
+            <item index="102" class="java.lang.String" itemvalue="faiss-gpu" />
+            <item index="103" class="java.lang.String" itemvalue="aiocron" />
+            <item index="104" class="java.lang.String" itemvalue="tzdata" />
+            <item index="105" class="java.lang.String" itemvalue="dill" />
+            <item index="106" class="java.lang.String" itemvalue="nvidia-cudnn-cu12" />
+            <item index="107" class="java.lang.String" itemvalue="torch" />
+            <item index="108" class="java.lang.String" itemvalue="et-xmlfile" />
+            <item index="109" class="java.lang.String" itemvalue="python-multipart" />
+            <item index="110" class="java.lang.String" itemvalue="tqdm" />
+            <item index="111" class="java.lang.String" itemvalue="aiohttp" />
+            <item index="112" class="java.lang.String" itemvalue="multidict" />
+            <item index="113" class="java.lang.String" itemvalue="responses" />
+            <item index="114" class="java.lang.String" itemvalue="pytz" />
+            <item index="115" class="java.lang.String" itemvalue="openpyxl" />
+            <item index="116" class="java.lang.String" itemvalue="tomli" />
+            <item index="117" class="java.lang.String" itemvalue="asyncio" />
+            <item index="118" class="java.lang.String" itemvalue="colorama" />
+            <item index="119" class="java.lang.String" itemvalue="zope.interface" />
+            <item index="120" class="java.lang.String" itemvalue="setuptools" />
+            <item index="121" class="java.lang.String" itemvalue="click" />
+            <item index="122" class="java.lang.String" itemvalue="vellum-ai" />
+            <item index="123" class="java.lang.String" itemvalue="Pillow" />
+            <item index="124" class="java.lang.String" itemvalue="langchain-community" />
+            <item index="125" class="java.lang.String" itemvalue="langchain-openai" />
+            <item index="126" class="java.lang.String" itemvalue="langchain" />
+            <item index="127" class="java.lang.String" itemvalue="langchain-core" />
+            <item index="128" class="java.lang.String" itemvalue="langchain-text-splitters" />
+            <item index="129" class="java.lang.String" itemvalue="langsmith" />
+            <item index="130" class="java.lang.String" itemvalue="selenium" />
+            <item index="131" class="java.lang.String" itemvalue="selectolax" />
+            <item index="132" class="java.lang.String" itemvalue="apscheduler" />
+            <item index="133" class="java.lang.String" itemvalue="fake-useragent" />
+            <item index="134" class="java.lang.String" itemvalue="aiofiles" />
+            <item index="135" class="java.lang.String" itemvalue="lxml" />
+            <item index="136" class="java.lang.String" itemvalue="html2text" />
+            <item index="137" class="java.lang.String" itemvalue="linkedin_api" />
+            <item index="138" class="java.lang.String" itemvalue="pydantic-settings" />
+            <item index="139" class="java.lang.String" itemvalue="langchain-mongodb" />
+            <item index="140" class="java.lang.String" itemvalue="jiter" />
+            <item index="141" class="java.lang.String" itemvalue="langchainhub" />
+            <item index="142" class="java.lang.String" itemvalue="langchain-experimental" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="N802" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/lab4.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.12 (lab4)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.12 (lab4)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/lab4.iml" filepath="$PROJECT_DIR$/.idea/lab4.iml" />
+    </modules>
+  </component>
+</project>

.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python Debugger: FastAPI",
+            "type": "debugpy",
+            "request": "launch",
+            "module": "uvicorn",
+            "args": [
+                "main:app",
+                "--reload"
+            ],
+            "jinja": true,
+            "preLaunchTask": "kill_old_fastapi_process"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,20 @@
+{
+    "files.exclude": {
+        "**/__pycache__": true,
+        "**/.git": true,
+        "**/.DS_Store": true,
+        "**/.idea": true,
+        "**/.github": true,
+        "**/.venv": true,
+        "**/.history": true
+    },
+    "search.exclude": {
+        "**/.github": true,
+        "**/.vscode": true,
+        "**/.DS_Store": true,
+        "**/.idea": true,
+        "**/.git": true,
+        "**/.venv": true,
+        "**/.history": true
+    },
+}

.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "kill_old_fastapi_process",
+            "type": "shell",
+            "command": "lsof -ti :8000 | xargs kill -9",
+            "problemMatcher": [],
+            "group": "build",
+            "presentation": {
+                "reveal": "never"
+            }
+        }
+    ]
+}

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.12.7
+
+RUN apt-get update && apt-get install -y libgl1 && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,10 @@
+---
+title: lab4
+emoji: 🐢
+colorFrom: purple
+colorTo: blue
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/__init__.py

@@ -0,0 +1,26 @@
+from fastapi import FastAPI
+
+from app.api.messages.views import router as messages_router
+from app.api.participants.views import router as participants_router
+from app.api.topics.views import router as topics_router
+from app.core.config import (
+    APP_TITLE,
+    PARTICIPANTS_ROUTE_PREFIX,
+    PARTICIPANTS_TAG,
+    MESSAGES_ROUTE_PREFIX,
+    MESSAGES_TAG,
+    TOPICS_ROUTE_PREFIX,
+    TOPICS_TAG,
+)
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(title=APP_TITLE)
+    app.include_router(participants_router, prefix=PARTICIPANTS_ROUTE_PREFIX, tags=[PARTICIPANTS_TAG])
+    app.include_router(messages_router, prefix=MESSAGES_ROUTE_PREFIX, tags=[MESSAGES_TAG])
+    app.include_router(topics_router, prefix=TOPICS_ROUTE_PREFIX, tags=[TOPICS_TAG])
+    return app
+
+
+__all__ = ["create_app"]
+

app/api/messages/__init__.py

@@ -0,0 +1 @@
+__all__ = []

app/api/messages/parser.py

@@ -0,0 +1,71 @@
+import base64
+from datetime import datetime
+from uuid import UUID
+
+from app.api.messages.schemas import Message
+from app.core.config import (
+    ENCODING_ASCII,
+    ENCODING_UTF8,
+    MESSAGE_EXPECTED_PARTS,
+    MESSAGE_PARSE_EMPTY_ERROR,
+    MESSAGE_PARSE_INVALID_ERROR,
+    MESSAGE_SEPARATOR,
+    TABLE_PARTICIPANTS,
+    TABLE_TOPICS,
+)
+from app.core.link import Link
+
+
+class MessageLineParser:
+    SEPARATOR = MESSAGE_SEPARATOR
+    EXPECTED_PARTS = MESSAGE_EXPECTED_PARTS
+
+    @staticmethod
+    def _decode_content(encoded: str) -> str:
+        return base64.b64decode(encoded.encode(ENCODING_ASCII)).decode(ENCODING_UTF8)
+
+    @staticmethod
+    def _encode_content(value: str) -> str:
+        return base64.b64encode(value.encode(ENCODING_UTF8)).decode(ENCODING_ASCII)
+
+    @classmethod
+    def parse(cls, line: str) -> Message:
+        raw = line.strip()
+        if not raw:
+            raise ValueError(MESSAGE_PARSE_EMPTY_ERROR)
+
+        parts = raw.split(cls.SEPARATOR)
+        if len(parts) != cls.EXPECTED_PARTS:
+            raise ValueError(MESSAGE_PARSE_INVALID_ERROR)
+
+        (
+            message_id,
+            topic_raw,
+            order_in_topic,
+            participant_raw,
+            created_at_value,
+            encoded_content,
+        ) = parts
+
+        return Message(
+            id=UUID(message_id),
+            topic_id=Link.from_raw(topic_raw, default_table=TABLE_TOPICS),
+            order_in_topic=int(order_in_topic),
+            participant_id=Link.from_raw(participant_raw, default_table=TABLE_PARTICIPANTS),
+            created_at=datetime.fromisoformat(created_at_value),
+            content=cls._decode_content(encoded_content),
+        )
+
+    @classmethod
+    def serialize(cls, message: Message) -> str:
+        return cls.SEPARATOR.join(
+            [
+                str(message.id),
+                message.topic_id.as_path(),
+                str(message.order_in_topic),
+                message.participant_id.as_path(),
+                message.created_at.isoformat(),
+                cls._encode_content(message.content),
+            ]
+        )
+

app/api/messages/schemas.py

@@ -0,0 +1,28 @@
+from datetime import datetime
+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
+
+
+class MessageBase(BaseModel):
+    topic_id: Link
+    participant_id: Link
+    content: str = Field(min_length=TOPIC_MESSAGE_MIN_LENGTH, max_length=TOPIC_MESSAGE_MAX_LENGTH)
+
+
+class MessageCreate(MessageBase):
+    pass
+
+
+class Message(MessageBase):
+    id: UUID
+    order_in_topic: int
+    created_at: datetime
+
+
+class MessageResponse(Message):
+    participant_name: str
+    topic_title: str

app/api/messages/services.py

@@ -0,0 +1,128 @@
+from datetime import datetime
+from typing import List, Optional
+from uuid import UUID, uuid4
+
+from fastapi import HTTPException, status
+
+from app.api.messages.parser import MessageLineParser
+from app.api.messages.schemas import Message, MessageCreate
+from app.api.participants.parser import ParticipantLineParser
+from app.api.participants.schemas import Participant
+from app.api.topics.schemas import Topic
+from app.core.config import (
+    FORBIDDEN_WORDS,
+    FORBIDDEN_WORDS_MESSAGE,
+    PARTICIPANT_NOT_FOUND_MESSAGE,
+    TABLE_PARTICIPANTS,
+    TABLE_TOPICS,
+    TOPIC_NOT_FOUND_MESSAGE,
+)
+from app.core.file_manager import FileManager
+from app.core.link import Link
+
+
+class MessageService:
+    def __init__(
+        self,
+        file_manager: FileManager,
+        topic_file_manager: FileManager,
+        participant_file_manager: FileManager,
+    ) -> None:
+        self.file_manager = file_manager
+        self.topic_file_manager = topic_file_manager
+        self.participant_file_manager = participant_file_manager
+
+    def _check_forbidden_words(self, content: str) -> Optional[str]:
+        content_lower = content.lower()
+        for word in FORBIDDEN_WORDS:
+            if word in content_lower:
+                return word
+        return None
+
+    def _load_topics(self) -> List[Topic]:
+        from app.api.topics.parser import TopicLineParser
+
+        topics: List[Topic] = []
+        for line in self.topic_file_manager.read_lines():
+            try:
+                topics.append(TopicLineParser.parse(line))
+            except ValueError:
+                continue
+        return topics
+
+    def _load_participants(self) -> List[Participant]:
+        participants: List[Participant] = []
+        for line in self.participant_file_manager.read_lines():
+            try:
+                participants.append(ParticipantLineParser.parse(line))
+            except ValueError:
+                continue
+        return participants
+
+    def _get_topic_by_id(self, topic_id: UUID) -> Topic:
+        for topic in self._load_topics():
+            if topic.id == topic_id:
+                return topic
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=TOPIC_NOT_FOUND_MESSAGE,
+        )
+
+    def _get_participant_by_id(self, participant_id: UUID) -> Participant:
+        for participant in self._load_participants():
+            if participant.id == participant_id:
+                return participant
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=PARTICIPANT_NOT_FOUND_MESSAGE,
+        )
+
+    def _resolve_id(self, link: Link, expected_table: str) -> UUID:
+        return link.resolve({expected_table: lambda value: value})
+
+    def get_topic(self, topic_link: Link) -> Topic:
+        topic_id = self._resolve_id(topic_link, TABLE_TOPICS)
+        return self._get_topic_by_id(topic_id)
+
+    def get_participant(self, participant_link: Link) -> Participant:
+        participant_id = self._resolve_id(participant_link, TABLE_PARTICIPANTS)
+        return self._get_participant_by_id(participant_id)
+
+    def list_messages(self) -> List[Message]:
+        messages: List[Message] = []
+        for line in self.file_manager.read_lines():
+            try:
+                messages.append(MessageLineParser.parse(line))
+            except ValueError:
+                continue
+        return messages
+
+    def list_messages_by_topic(self, topic_id: Link) -> List[Message]:
+        topic_value = self._resolve_id(topic_id, TABLE_TOPICS)
+        messages = [message for message in self.list_messages() if message.topic_id.value == topic_value]
+        return sorted(messages, key=lambda message: message.order_in_topic)
+
+    def create_message(self, payload: MessageCreate) -> Message:
+        forbidden_word = self._check_forbidden_words(payload.content)
+        if forbidden_word:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"{FORBIDDEN_WORDS_MESSAGE}: '{forbidden_word}'",
+            )
+
+        self.get_topic(payload.topic_id)
+        self.get_participant(payload.participant_id)
+
+        next_order = len(self.list_messages_by_topic(payload.topic_id)) + 1
+        message = Message(
+            id=uuid4(),
+            topic_id=payload.topic_id,
+            participant_id=payload.participant_id,
+            content=payload.content,
+            order_in_topic=next_order,
+            created_at=datetime.utcnow(),
+        )
+        serialized = MessageLineParser.serialize(message)
+        self.file_manager.append_line(serialized)
+        return message
+

app/api/messages/views.py

@@ -0,0 +1,85 @@
+from typing import List
+from uuid import UUID
+
+from fastapi import APIRouter
+
+from app.api.messages.schemas import Message, MessageResponse
+from app.api.messages.services import MessageService
+from app.api.participants.schemas import Participant
+from app.api.participants.services import ParticipantService
+from app.api.topics.schemas import Topic
+from app.core.config import (
+    MESSAGES_FILE,
+    PARTICIPANTS_FILE,
+    TABLE_TOPICS,
+    TOPICS_FILE,
+    UNKNOWN_PARTICIPANT_NAME,
+    UNKNOWN_TOPIC_TITLE,
+)
+from app.core.file_manager import FileManager
+from app.core.link import Link
+
+
+router = APIRouter()
+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 _list_topics() -> List[Topic]:
+    from app.api.topics.parser import TopicLineParser
+
+    topics: List[Topic] = []
+    for line in topic_file_manager.read_lines():
+        try:
+            topics.append(TopicLineParser.parse(line))
+        except ValueError:
+            continue
+    return topics
+
+
+def _message_to_response(message: Message, participants: List[Participant], topics: List[Topic]) -> MessageResponse:
+    return MessageResponse(
+        id=message.id,
+        topic_id=message.topic_id,
+        order_in_topic=message.order_in_topic,
+        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),
+    )
+
+
+@router.get("/", response_model=List[MessageResponse])
+async def list_messages() -> List[MessageResponse]:
+    messages = message_service.list_messages()
+    participants = participant_service.list_participants()
+    topics = _list_topics()
+    messages.sort(key=lambda message: (message.topic_id.value, message.order_in_topic))
+    return [_message_to_response(message, participants, topics) for message in messages]
+
+
+@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)
+    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]
+

app/api/participants/__init__.py

@@ -0,0 +1 @@
+__all__ = []

app/api/participants/parser.py

@@ -0,0 +1,51 @@
+from datetime import datetime
+from uuid import UUID
+
+from app.api.participants.schemas import Participant
+from app.core.config import (
+    PARTICIPANT_EXPECTED_PARTS,
+    PARTICIPANT_PARSE_EMPTY_ERROR,
+    PARTICIPANT_PARSE_INVALID_ERROR,
+    PARTICIPANT_SEPARATOR,
+)
+
+
+class ParticipantLineParser:
+    SEPARATOR = PARTICIPANT_SEPARATOR
+    EXPECTED_PARTS = PARTICIPANT_EXPECTED_PARTS
+
+    @classmethod
+    def parse(cls, line: str) -> Participant:
+        raw = line.strip()
+        if not raw:
+            raise ValueError(PARTICIPANT_PARSE_EMPTY_ERROR)
+
+        parts = raw.split(cls.SEPARATOR)
+        if len(parts) != cls.EXPECTED_PARTS:
+            raise ValueError(PARTICIPANT_PARSE_INVALID_ERROR)
+
+        participant_id, first_name, last_name, nickname, registered_at, activity_rating = parts
+        return Participant(
+            id=UUID(participant_id),
+            first_name=first_name,
+            last_name=last_name,
+            nickname=nickname,
+            registered_at=datetime.fromisoformat(registered_at),
+            activity_rating=float(activity_rating),
+        )
+
+    @classmethod
+    def serialize(cls, participant: Participant) -> str:
+        return cls.SEPARATOR.join(
+            [
+                str(participant.id),
+                participant.first_name,
+                participant.last_name,
+                participant.nickname,
+                participant.registered_at.isoformat(),
+                f"{participant.activity_rating}",
+            ]
+        )
+
+
+

app/api/participants/schemas.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+from app.core.config import NAME_MAX_LENGTH, NAME_MIN_LENGTH, RATING_MIN_VALUE
+
+
+class ParticipantBase(BaseModel):
+    first_name: str = Field(min_length=NAME_MIN_LENGTH, max_length=NAME_MAX_LENGTH)
+    last_name: str = Field(min_length=NAME_MIN_LENGTH, max_length=NAME_MAX_LENGTH)
+    nickname: str = Field(min_length=NAME_MIN_LENGTH, max_length=NAME_MAX_LENGTH)
+    activity_rating: float = Field(ge=RATING_MIN_VALUE)
+
+
+class ParticipantCreate(ParticipantBase):
+    pass
+
+
+class Participant(ParticipantBase):
+    id: UUID
+    registered_at: datetime
+
+
+

app/api/participants/services.py

@@ -0,0 +1,49 @@
+from datetime import datetime
+from typing import List
+from uuid import UUID, uuid4
+
+from fastapi import HTTPException, status
+
+from app.api.participants.parser import ParticipantLineParser
+from app.api.participants.schemas import Participant, ParticipantCreate
+from app.core.config import PARTICIPANT_NOT_FOUND_MESSAGE
+from app.core.file_manager import FileManager
+
+
+class ParticipantService:
+    def __init__(self, file_manager: FileManager) -> None:
+        self.file_manager = file_manager
+
+    def list_participants(self) -> List[Participant]:
+        participants: List[Participant] = []
+        for line in self.file_manager.read_lines():
+            try:
+                participants.append(ParticipantLineParser.parse(line))
+            except ValueError:
+                continue
+        return participants
+
+    def get_participant(self, participant_id: UUID) -> Participant:
+        for participant in self.list_participants():
+            if participant.id == participant_id:
+                return participant
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=PARTICIPANT_NOT_FOUND_MESSAGE,
+        )
+
+    def create_participant(self, payload: ParticipantCreate) -> Participant:
+        participant = Participant(
+            id=uuid4(),
+            first_name=payload.first_name,
+            last_name=payload.last_name,
+            nickname=payload.nickname,
+            registered_at=datetime.utcnow(),
+            activity_rating=payload.activity_rating,
+        )
+        serialized = ParticipantLineParser.serialize(participant)
+        self.file_manager.append_line(serialized)
+        return participant
+
+
+

app/api/participants/views.py

@@ -0,0 +1,31 @@
+from typing import List
+from uuid import UUID
+
+from fastapi import APIRouter
+
+from app.api.participants.schemas import Participant, ParticipantCreate
+from app.api.participants.services import ParticipantService
+from app.core.config import HTTP_STATUS_CREATED, PARTICIPANTS_FILE
+from app.core.file_manager import FileManager
+
+
+router = APIRouter()
+participant_service = ParticipantService(FileManager(PARTICIPANTS_FILE))
+
+
+@router.get("/", response_model=List[Participant])
+async def list_participants() -> List[Participant]:
+    return participant_service.list_participants()
+
+
+@router.get("/{participant_id}", response_model=Participant)
+async def get_participant(participant_id: UUID) -> Participant:
+    return participant_service.get_participant(participant_id)
+
+
+@router.post("/", response_model=Participant, status_code=HTTP_STATUS_CREATED)
+async def create_participant(payload: ParticipantCreate) -> Participant:
+    return participant_service.create_participant(payload)
+
+
+

app/api/topics/__init__.py

@@ -0,0 +1 @@
+__all__ = []

app/api/topics/parser.py

@@ -0,0 +1,126 @@
+import base64
+from datetime import datetime
+from typing import List
+from uuid import UUID
+
+from app.api.topics.schemas import Topic, TopicMessage
+from app.core.config import (
+    ENCODING_ASCII,
+    ENCODING_UTF8,
+    TABLE_PARTICIPANTS,
+    TOPIC_EXPECTED_PARTS,
+    TOPIC_INNER_SEPARATOR,
+    TOPIC_LIST_SEPARATOR,
+    TOPIC_MESSAGE_PART_SEPARATOR,
+    TOPIC_PARSE_EMPTY_ERROR,
+    TOPIC_PARSE_INVALID_ERROR,
+    TOPIC_SEPARATOR,
+)
+from app.core.link import Link
+
+
+class TopicLineParser:
+    SEPARATOR = TOPIC_SEPARATOR
+    EXPECTED_PARTS = TOPIC_EXPECTED_PARTS
+    LIST_SEPARATOR = TOPIC_LIST_SEPARATOR
+    INNER_SEPARATOR = TOPIC_INNER_SEPARATOR
+    MESSAGE_PART_SEPARATOR = TOPIC_MESSAGE_PART_SEPARATOR
+
+    @staticmethod
+    def _decode_message(encoded: str) -> str:
+        return base64.b64decode(encoded.encode(ENCODING_ASCII)).decode(ENCODING_UTF8)
+
+    @staticmethod
+    def _encode_message(value: str) -> str:
+        return base64.b64encode(value.encode(ENCODING_UTF8)).decode(ENCODING_ASCII)
+
+    @classmethod
+    def _parse_participants(cls, raw: str) -> List[Link]:
+        if not raw:
+            return []
+        links: List[Link] = []
+        for value in raw.split(cls.INNER_SEPARATOR):
+            if not value:
+                continue
+            links.append(Link.from_raw(value, default_table=TABLE_PARTICIPANTS))
+        return links
+
+    @classmethod
+    def _parse_messages(cls, raw: str) -> List[TopicMessage]:
+        if not raw:
+            return []
+        messages: List[TopicMessage] = []
+        for chunk in raw.split(cls.LIST_SEPARATOR):
+            if not chunk:
+                continue
+            try:
+                participant_raw, encoded_content = chunk.split(cls.MESSAGE_PART_SEPARATOR, 1)
+            except ValueError:
+                continue
+            messages.append(
+                TopicMessage(
+                    participant_id=Link.from_raw(participant_raw, default_table=TABLE_PARTICIPANTS),
+                    content=cls._decode_message(encoded_content),
+                )
+            )
+        return messages
+
+    @classmethod
+    def _serialize_participants(cls, participants: List[Link]) -> str:
+        return cls.INNER_SEPARATOR.join(participant.as_path() for participant in participants)
+
+    @classmethod
+    def _serialize_messages(cls, messages: List[TopicMessage]) -> str:
+        return cls.LIST_SEPARATOR.join(
+            cls.MESSAGE_PART_SEPARATOR.join(
+                [message.participant_id.as_path(), cls._encode_message(message.content)]
+            )
+            for message in messages
+        )
+
+    @classmethod
+    def parse(cls, line: str) -> Topic:
+        raw = line.strip()
+        if not raw:
+            raise ValueError(TOPIC_PARSE_EMPTY_ERROR)
+
+        parts = raw.split(cls.SEPARATOR)
+        if len(parts) != cls.EXPECTED_PARTS:
+            raise ValueError(TOPIC_PARSE_INVALID_ERROR)
+
+        (
+            topic_id,
+            title,
+            description,
+            created_at_value,
+            participants_raw,
+            messages_raw,
+        ) = parts
+
+        participants = cls._parse_participants(participants_raw)
+        messages = cls._parse_messages(messages_raw)
+
+        return Topic(
+            id=UUID(topic_id),
+            title=title,
+            description=description,
+            created_at=datetime.fromisoformat(created_at_value),
+            participants=participants,
+            messages=messages,
+        )
+
+    @classmethod
+    def serialize(cls, topic: Topic) -> str:
+        return cls.SEPARATOR.join(
+            [
+                str(topic.id),
+                topic.title,
+                topic.description,
+                topic.created_at.isoformat(),
+                cls._serialize_participants(topic.participants),
+                cls._serialize_messages(topic.messages),
+            ]
+        )
+
+
+

app/api/topics/schemas.py

@@ -0,0 +1,66 @@
+from datetime import datetime
+from typing import List
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+from app.core.config import (
+    TOPIC_DESCRIPTION_MAX_LENGTH,
+    TOPIC_DESCRIPTION_MIN_LENGTH,
+    TOPIC_MESSAGE_MAX_LENGTH,
+    TOPIC_MESSAGE_MIN_LENGTH,
+    TOPIC_TITLE_MAX_LENGTH,
+    TOPIC_TITLE_MIN_LENGTH,
+)
+from app.core.link import Link
+
+
+class TopicMessageBase(BaseModel):
+    participant_id: Link
+    content: str = Field(min_length=TOPIC_MESSAGE_MIN_LENGTH, max_length=TOPIC_MESSAGE_MAX_LENGTH)
+    order_in_topic: int | None = None
+
+
+class TopicMessageCreate(TopicMessageBase):
+    pass
+
+
+class TopicMessage(TopicMessageBase):
+    pass
+
+
+class TopicMessageResponse(TopicMessageBase):
+    participant_name: str
+
+
+class TopicBase(BaseModel):
+    title: str = Field(min_length=TOPIC_TITLE_MIN_LENGTH, max_length=TOPIC_TITLE_MAX_LENGTH)
+    description: str = Field(
+        min_length=TOPIC_DESCRIPTION_MIN_LENGTH,
+        max_length=TOPIC_DESCRIPTION_MAX_LENGTH,
+    )
+    participants: List[Link] = Field(default_factory=list)
+
+
+class TopicCreate(TopicBase):
+    messages: List[TopicMessageCreate] = Field(default_factory=list)
+
+
+class Topic(BaseModel):
+    id: UUID
+    title: str
+    description: str
+    created_at: datetime
+    participants: List[Link] = Field(default_factory=list)
+    messages: List[TopicMessage] = Field(default_factory=list)
+
+
+class TopicResponse(TopicBase):
+    id: UUID
+    created_at: datetime
+    messages: List[TopicMessageResponse] = Field(default_factory=list)
+
+
+class AddMessageRequest(BaseModel):
+    participant_id: Link
+    content: str = Field(min_length=TOPIC_MESSAGE_MIN_LENGTH, max_length=TOPIC_MESSAGE_MAX_LENGTH)

app/api/topics/services.py

@@ -0,0 +1,134 @@
+from datetime import datetime
+from typing import List, Optional
+from uuid import UUID, uuid4
+
+from fastapi import HTTPException, status
+
+from app.api.messages.schemas import MessageCreate
+from app.api.messages.services import MessageService
+from app.api.topics.parser import TopicLineParser
+from app.api.topics.schemas import AddMessageRequest, Topic, TopicCreate, TopicMessage
+from app.core.config import (
+    FORBIDDEN_WORDS,
+    FORBIDDEN_WORDS_MESSAGE,
+    TABLE_TOPICS,
+    TOPIC_NOT_FOUND_MESSAGE,
+)
+from app.core.file_manager import FileManager
+from app.core.link import Link
+
+
+class TopicService:
+    def __init__(self, file_manager: FileManager, message_service: MessageService | None = None) -> None:
+        self.file_manager = file_manager
+        self.message_service = message_service
+
+    @staticmethod
+    def _resolve_topic_id(value: UUID | Link) -> UUID:
+        if isinstance(value, UUID):
+            return value
+        return value.resolve({TABLE_TOPICS: lambda link_value: link_value})
+
+    def list_topics(self) -> List[Topic]:
+        topics: List[Topic] = []
+        for line in self.file_manager.read_lines():
+            try:
+                topics.append(TopicLineParser.parse(line))
+            except ValueError:
+                continue
+        return topics
+
+    def get_topic(self, topic_id: UUID | Link) -> Topic:
+        resolved_id = self._resolve_topic_id(topic_id)
+        for topic in self.list_topics():
+            if topic.id == resolved_id:
+                return topic
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=TOPIC_NOT_FOUND_MESSAGE,
+        )
+
+    def create_topic(self, payload: TopicCreate) -> Topic:
+        topic_messages = (
+            []
+            if self.message_service
+            else [
+                TopicMessage(
+                    participant_id=message.participant_id,
+                    content=message.content,
+                )
+                for message in payload.messages
+            ]
+        )
+        topic = Topic(
+            id=uuid4(),
+            title=payload.title,
+            description=payload.description,
+            created_at=datetime.utcnow(),
+            participants=payload.participants,
+            messages=topic_messages,
+        )
+        serialized = TopicLineParser.serialize(topic)
+        self.file_manager.append_line(serialized)
+        if self.message_service:
+            for message in payload.messages:
+                self.message_service.create_message(
+                    MessageCreate(
+                        topic_id=Link(table=TABLE_TOPICS, value=topic.id),
+                        participant_id=message.participant_id,
+                        content=message.content,
+                    )
+                )
+        return topic
+
+    @staticmethod
+    def check_forbidden_words(content: str) -> Optional[str]:
+        content_lower = content.lower()
+        for word in FORBIDDEN_WORDS:
+            if word in content_lower:
+                return word
+        return None
+
+    def add_message(self, topic_id: UUID | Link, payload: AddMessageRequest) -> Topic:
+        forbidden_word = self.check_forbidden_words(payload.content)
+        if forbidden_word:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"{FORBIDDEN_WORDS_MESSAGE}: '{forbidden_word}'",
+            )
+
+        resolved_id = self._resolve_topic_id(topic_id)
+
+        if self.message_service:
+            self.message_service.create_message(
+                MessageCreate(
+                    topic_id=Link(table=TABLE_TOPICS, value=resolved_id),
+                    participant_id=payload.participant_id,
+                    content=payload.content,
+                )
+            )
+            return self.get_topic(resolved_id)
+
+        topics = self.list_topics()
+        topic_index = None
+        for i, topic in enumerate(topics):
+            if topic.id == resolved_id:
+                topic_index = i
+                break
+
+        if topic_index is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=TOPIC_NOT_FOUND_MESSAGE,
+            )
+
+        new_message = TopicMessage(
+            participant_id=payload.participant_id,
+            content=payload.content,
+        )
+        topics[topic_index].messages.append(new_message)
+
+        lines = [TopicLineParser.serialize(t) for t in topics]
+        self.file_manager.write_lines(lines)
+
+        return topics[topic_index]

app/api/topics/views.py

@@ -0,0 +1,101 @@
+from typing import List
+from uuid import UUID
+
+from fastapi import APIRouter
+
+from app.api.messages.schemas import Message
+from app.api.messages.services import MessageService
+from app.api.participants.schemas import Participant
+from app.api.participants.services import ParticipantService
+from app.api.topics.schemas import (
+    AddMessageRequest,
+    Topic,
+    TopicCreate,
+    TopicMessageResponse,
+    TopicResponse,
+)
+from app.api.topics.services import TopicService
+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
+
+
+router = APIRouter()
+message_service = MessageService(FileManager(MESSAGES_FILE), FileManager(TOPICS_FILE), FileManager(PARTICIPANTS_FILE))
+topic_service = TopicService(FileManager(TOPICS_FILE), message_service=message_service)
+participant_service = ParticipantService(FileManager(PARTICIPANTS_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 _topic_to_response(topic: Topic, participants: List[Participant], messages: List[Message]) -> TopicResponse:
+    message_responses = []
+    for message in sorted(messages, key=lambda item: item.order_in_topic):
+        message_responses.append(
+            TopicMessageResponse(
+                participant_id=message.participant_id,
+                content=message.content,
+                participant_name=_resolve_participant_name(message.participant_id, participants),
+                order_in_topic=message.order_in_topic,
+            )
+        )
+    return TopicResponse(
+        id=topic.id,
+        title=topic.title,
+        description=topic.description,
+        created_at=topic.created_at,
+        participants=topic.participants,
+        messages=message_responses,
+    )
+
+
+@router.get("/", response_model=List[TopicResponse])
+async def list_topics() -> List[TopicResponse]:
+    topics = topic_service.list_topics()
+    participants = participant_service.list_participants()
+    messages = message_service.list_messages()
+    messages_by_topic: dict[UUID, List[Message]] = {}
+    for message in messages:
+        messages_by_topic.setdefault(message.topic_id.value, []).append(message)
+    return [
+        _topic_to_response(topic, participants, messages_by_topic.get(topic.id, []))
+        for topic in topics
+    ]
+
+
+@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 = topic_service.get_topic(topic_link)
+    participants = participant_service.list_participants()
+    topic_messages = message_service.list_messages_by_topic(topic_link)
+    return _topic_to_response(topic, participants, topic_messages)
+
+
+@router.post("/", response_model=TopicResponse, status_code=HTTP_STATUS_CREATED)
+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))
+    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 = 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)

app/core/__init__.py

@@ -0,0 +1,4 @@
+
+
+
+

app/core/config.py

@@ -0,0 +1,71 @@
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+DATA_DIR = BASE_DIR / "data"
+TABLE_PARTICIPANTS = "participants"
+TABLE_TOPICS = "topics"
+TABLE_MESSAGES = "messages"
+
+PARTICIPANTS_FILE = DATA_DIR / "participants.txt"
+TOPICS_FILE = DATA_DIR / "topics.txt"
+MESSAGES_FILE = DATA_DIR / "messages.txt"
+
+PARTICIPANT_SEPARATOR = "|"
+PARTICIPANT_EXPECTED_PARTS = 6
+
+TOPIC_SEPARATOR = "|"
+TOPIC_EXPECTED_PARTS = 6
+TOPIC_LIST_SEPARATOR = ";"
+TOPIC_INNER_SEPARATOR = ","
+TOPIC_MESSAGE_PART_SEPARATOR = "^"
+
+MESSAGE_SEPARATOR = "|"
+MESSAGE_EXPECTED_PARTS = 6
+
+ENCODING_UTF8 = "utf-8"
+ENCODING_ASCII = "ascii"
+NEWLINE = "\n"
+
+NAME_MIN_LENGTH = 1
+NAME_MAX_LENGTH = 100
+RATING_MIN_VALUE = 0
+
+TOPIC_TITLE_MIN_LENGTH = 1
+TOPIC_TITLE_MAX_LENGTH = 200
+TOPIC_DESCRIPTION_MIN_LENGTH = 1
+TOPIC_DESCRIPTION_MAX_LENGTH = 1000
+TOPIC_MESSAGE_MIN_LENGTH = 1
+TOPIC_MESSAGE_MAX_LENGTH = 2000
+
+PARTICIPANT_PARSE_EMPTY_ERROR = "Cannot parse empty participant line"
+PARTICIPANT_PARSE_INVALID_ERROR = "Invalid participant line format"
+TOPIC_PARSE_EMPTY_ERROR = "Cannot parse empty topic line"
+TOPIC_PARSE_INVALID_ERROR = "Invalid topic line format"
+MESSAGE_PARSE_EMPTY_ERROR = "Cannot parse empty message line"
+MESSAGE_PARSE_INVALID_ERROR = "Invalid message line format"
+
+PARTICIPANT_NOT_FOUND_MESSAGE = "Participant not found"
+TOPIC_NOT_FOUND_MESSAGE = "Topic not found"
+MESSAGE_NOT_FOUND_MESSAGE = "Message not found"
+UNKNOWN_PARTICIPANT_NAME = "Unknown participant"
+UNKNOWN_TOPIC_TITLE = "Unknown topic"
+
+APP_TITLE = "Forum Storage API"
+PARTICIPANTS_ROUTE_PREFIX = "/participants"
+TOPICS_ROUTE_PREFIX = "/topics"
+MESSAGES_ROUTE_PREFIX = "/messages"
+PARTICIPANTS_TAG = "participants"
+TOPICS_TAG = "topics"
+MESSAGES_TAG = "messages"
+
+HTTP_STATUS_CREATED = 201
+
+FORBIDDEN_WORDS = ["spam", "hate", "violence", "abuse", "illegal"]
+FORBIDDEN_WORDS_MESSAGE = "Message contains forbidden words"
+
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+PARTICIPANTS_FILE.touch(exist_ok=True)
+TOPICS_FILE.touch(exist_ok=True)
+MESSAGES_FILE.touch(exist_ok=True)
+
+

app/core/file_manager.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+from typing import Iterable, List
+
+from app.core.config import ENCODING_UTF8, NEWLINE
+
+
+class FileManager:
+    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)
+
+    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()]
+
+    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}")
+
+    def append_line(self, line: str) -> None:
+        with self.file_path.open("a", encoding=ENCODING_UTF8) as file:
+            file.write(f"{line}{NEWLINE}")
+
+
+

app/core/link.py

@@ -0,0 +1,38 @@
+from typing import Any, Callable
+from uuid import UUID
+
+from fastapi import HTTPException, status
+from pydantic import BaseModel
+
+
+class Link(BaseModel):
+    table: str
+    value: UUID
+
+    def resolve(self, resolvers: dict[str, Callable[[UUID], Any]]) -> Any:
+        resolver = resolvers.get(self.table)
+        if resolver is None:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Resolver for table '{self.table}' is not registered",
+            )
+        return resolver(self.value)
+
+    def as_path(self, leading_slash: bool = True) -> str:
+        path = f"{self.table}/{self.value}"
+        return f"/{path}" if leading_slash else path
+
+    @classmethod
+    def from_raw(cls, raw: str, default_table: str | None = None) -> "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))
+

client.py

@@ -0,0 +1,502 @@
+import re
+from enum import IntEnum
+from uuid import UUID
+
+import httpx
+
+BASE_URL = "http://127.0.0.1:8000"
+
+NEWLINE = "\n"
+SEPARATOR_60 = "=" * 60
+SEPARATOR_90 = "-" * 90
+DASH_LINE_60 = "-" * 60
+MAIN_MENU_TITLE = "           FORUM CLIENT - MAIN MENU"
+PROMPT_SELECT_OPTION = "Select option: "
+MSG_GOODBYE = "Goodbye!"
+LABEL_ALL_PARTICIPANTS = "ALL PARTICIPANTS:"
+LABEL_ALL_TOPICS = "ALL TOPICS:"
+LABEL_ALL_MESSAGES = "ALL MESSAGES:"
+LABEL_CREATE_PARTICIPANT = "CREATE NEW PARTICIPANT:"
+LABEL_CREATE_TOPIC = "CREATE NEW TOPIC:"
+LABEL_PUBLISH_MESSAGE = "PUBLISH MESSAGE TO TOPIC:"
+PROMPT_PARTICIPANT_ID = "Enter participant ID: "
+PROMPT_TOPIC_ID = "Enter topic ID: "
+PROMPT_TITLE = "  Title: "
+PROMPT_DESCRIPTION = "  Description: "
+PROMPT_FIRST_NAME = "  First name: "
+PROMPT_LAST_NAME = "  Last name: "
+PROMPT_NICKNAME = "  Nickname: "
+PROMPT_ACTIVITY = "  Activity rating: "
+PROMPT_TOPIC_ID_INLINE = "  Topic ID: "
+PROMPT_PARTICIPANT_ID_INLINE = "  Participant ID: "
+PROMPT_MESSAGE_CONTENT = "  Message content: "
+MSG_NO_PARTICIPANTS = "No participants found."
+MSG_NO_TOPICS = "No topics found."
+MSG_INVALID_OPTION = "Invalid option. Please try again."
+MSG_INVALID_UUID = "Invalid UUID format."
+MSG_GOODBYE_INTERRUPT = "\n\nInterrupted. Goodbye!"
+MSG_TOPIC_ID_REQUIRED = "Topic ID is required."
+MSG_PARTICIPANT_ID_REQUIRED = "Participant ID is required."
+MSG_TOPIC_NOT_FOUND = "Topic not found."
+MSG_PARTICIPANT_NOT_FOUND = "Participant not found."
+MSG_NO_MESSAGES = "    No messages yet."
+MSG_PARTICIPANT_CREATED = "\nParticipant created successfully!"
+MSG_TOPIC_CREATED = "\nTopic created successfully!"
+MSG_MESSAGE_PUBLISHED = "\nMessage published successfully!"
+MSG_ERROR_TEMPLATE = "Error: {status} - {text}"
+PARTICIPANT_NAME_RULE = "First name must contain only letters and '-'."
+PARTICIPANT_LAST_NAME_RULE = "Last name must contain only letters and '-'."
+PARTICIPANT_NICKNAME_RULE = "Nickname must contain only letters and '-'."
+ACTIVITY_RANGE_RULE = "Activity rating must be between 0.1 and 5.0."
+ACTIVITY_NUMBER_RULE = "Activity rating must be a number between 0.1 and 5.0."
+PARTICIPANT_TABLE_HEADER = f"{'ID':<40} {'Name':<25} {'Nickname':<15} {'Rating':<10}"
+PARTICIPANT_ROW_TEMPLATE = (
+    "{id:<40} {full_name:<25} {nickname:<15} {rating:<10}"
+)
+TOPIC_TITLE_TEMPLATE = "\nTopic: {title}"
+TOPIC_ID_TEMPLATE = "  ID: {id}"
+TOPIC_DESCRIPTION_TEMPLATE = "  Description: {description}"
+TOPIC_CREATED_TEMPLATE = "  Created: {created_at}"
+TOPIC_MESSAGES_TEMPLATE = "  Messages ({count}):"
+TOPIC_PARTICIPANTS_TEMPLATE = "  Participants: {count}"
+TOPIC_MESSAGE_TEMPLATE = "    {order}. [{participant_name}]: {content}"
+MESSAGE_LIST_TEMPLATE = "{topic_title} | #{order} [{participant_name}]: {content}"
+PARTICIPANT_SUMMARY_TEMPLATE = "\nParticipant: {first} {last}"
+PARTICIPANT_ID_TEMPLATE = "  ID: {id}"
+PARTICIPANT_NICKNAME_TEMPLATE = "  Nickname: {nickname}"
+PARTICIPANT_RATING_TEMPLATE = "  Rating: {rating}"
+PARTICIPANT_REGISTERED_TEMPLATE = "  Registered: {registered}"
+TOPIC_CREATED_ID_TEMPLATE = "  ID: {id}"
+PARTICIPANT_CREATED_ID_TEMPLATE = "  ID: {id}"
+TOPIC_MESSAGES_COUNT_TEMPLATE = "Topic now has {count} message(s)."
+RESULT_MESSAGE_TEMPLATE = "\n{result}"
+MENU_HEADER = NEWLINE + SEPARATOR_60
+
+class ForumClient:
+    def __init__(self, base_url: str = BASE_URL):
+        self.base_url = base_url
+        self.client = httpx.Client(timeout=30.0)
+
+    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 get_messages_by_topic(self, topic_id: str) -> list:
+        response = self.client.get(f"{self.base_url}/messages/topic/{topic_id}")
+        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": 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": 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 close(self):
+        self.client.close()
+
+
+def print_separator():
+    print(SEPARATOR_60)
+
+
+def print_participants(participants: list):
+    if not participants:
+        print(MSG_NO_PARTICIPANTS)
+        return
+    print(PARTICIPANT_TABLE_HEADER)
+    print(SEPARATOR_90)
+    for p in participants:
+        full_name = f"{p['first_name']} {p['last_name']}"
+        print(
+            PARTICIPANT_ROW_TEMPLATE.format(
+                id=p["id"],
+                full_name=full_name,
+                nickname=p["nickname"],
+                rating=p["activity_rating"],
+            )
+        )
+
+
+def print_topics(topics: list):
+    if not topics:
+        print(MSG_NO_TOPICS)
+        return
+    for topic in topics:
+        print(TOPIC_TITLE_TEMPLATE.format(title=topic["title"]))
+        print(TOPIC_ID_TEMPLATE.format(id=topic["id"]))
+        print(TOPIC_DESCRIPTION_TEMPLATE.format(description=topic["description"]))
+        print(TOPIC_CREATED_TEMPLATE.format(created_at=topic["created_at"]))
+        print(TOPIC_MESSAGES_TEMPLATE.format(count=len(topic["messages"])))
+        for msg in topic["messages"]:
+            print(
+                TOPIC_MESSAGE_TEMPLATE.format(
+                    participant_name=msg["participant_name"],
+                    content=msg["content"],
+                    order=msg.get("order_in_topic", 0),
+                )
+            )
+
+
+def print_topic_detail(topic: dict):
+    print(TOPIC_TITLE_TEMPLATE.format(title=topic["title"]))
+    print(TOPIC_ID_TEMPLATE.format(id=topic["id"]))
+    print(TOPIC_DESCRIPTION_TEMPLATE.format(description=topic["description"]))
+    print(TOPIC_CREATED_TEMPLATE.format(created_at=topic["created_at"]))
+    print(TOPIC_PARTICIPANTS_TEMPLATE.format(count=len(topic["participants"])))
+    print(NEWLINE + TOPIC_MESSAGES_TEMPLATE.format(count=len(topic["messages"])))
+    if not topic["messages"]:
+        print(MSG_NO_MESSAGES)
+    for msg in topic["messages"]:
+        print(
+            TOPIC_MESSAGE_TEMPLATE.format(
+                participant_name=msg["participant_name"],
+                content=msg["content"],
+                order=msg.get("order_in_topic", 0),
+            )
+        )
+
+
+def print_messages(messages: list):
+    if not messages:
+        print(MSG_NO_MESSAGES)
+        return
+    for msg in messages:
+        print(
+            MESSAGE_LIST_TEMPLATE.format(
+                topic_title=msg["topic_title"],
+                order=msg["order_in_topic"],
+                participant_name=msg["participant_name"],
+                content=msg["content"],
+            )
+        )
+
+
+def main_menu():
+    print(MENU_HEADER)
+    print(MAIN_MENU_TITLE)
+    print(SEPARATOR_60)
+    for option in MENU_OPTIONS:
+        print(option)
+    print(DASH_LINE_60)
+    return input(PROMPT_SELECT_OPTION).strip()
+
+
+class MenuChoice(IntEnum):
+    LIST_PARTICIPANTS = 1, "List all participants"
+    GET_PARTICIPANT = 2, "Get participant by ID"
+    CREATE_PARTICIPANT = 3, "Create new participant"
+    LIST_TOPICS = 4, "List all topics"
+    GET_TOPIC = 5, "Get topic by ID"
+    CREATE_TOPIC = 6, "Create new topic"
+    PUBLISH_MESSAGE = 7, "Publish message to topic"
+    LIST_MESSAGES = 8, "List all messages"
+    EXIT = 0, "Exit"
+
+    def __new__(cls, value, label=""):
+        obj = int.__new__(cls, value)
+        obj._value_ = value
+        obj.label = label
+        return obj
+
+
+MENU_OPTIONS = tuple(f"{choice.value}. {choice.label}" for choice in MenuChoice)
+
+
+def main():
+    client = ForumClient()
+
+    try:
+        while True:
+            raw_choice = main_menu()
+            try:
+                choice = MenuChoice(int(raw_choice))
+            except (ValueError, TypeError):
+                print(MSG_INVALID_OPTION)
+                continue
+
+            if choice == MenuChoice.EXIT:
+                print(MSG_GOODBYE)
+                break
+
+            elif choice == MenuChoice.LIST_PARTICIPANTS:
+                print_separator()
+                print(LABEL_ALL_PARTICIPANTS)
+                try:
+                    participants = client.get_participants()
+                    print_participants(participants)
+                except httpx.HTTPStatusError as e:
+                    print(
+                        MSG_ERROR_TEMPLATE.format(
+                            status=e.response.status_code, text=e.response.text
+                        )
+                    )
+
+            elif choice == MenuChoice.GET_PARTICIPANT:
+                print_separator()
+                participant_id = input(PROMPT_PARTICIPANT_ID).strip()
+                try:
+                    UUID(participant_id)
+                    participant = client.get_participant(participant_id)
+                    print(
+                        PARTICIPANT_SUMMARY_TEMPLATE.format(
+                            first=participant["first_name"],
+                            last=participant["last_name"],
+                        )
+                    )
+                    print(PARTICIPANT_ID_TEMPLATE.format(id=participant["id"]))
+                    print(
+                        PARTICIPANT_NICKNAME_TEMPLATE.format(
+                            nickname=participant["nickname"]
+                        )
+                    )
+                    print(
+                        PARTICIPANT_RATING_TEMPLATE.format(
+                            rating=participant["activity_rating"]
+                        )
+                    )
+                    print(
+                        PARTICIPANT_REGISTERED_TEMPLATE.format(
+                            registered=participant["registered_at"]
+                        )
+                    )
+                except ValueError:
+                    print(MSG_INVALID_UUID)
+                except httpx.HTTPStatusError as e:
+                    print(
+                        MSG_ERROR_TEMPLATE.format(
+                            status=e.response.status_code, text=e.response.text
+                        )
+                    )
+
+            elif choice == MenuChoice.CREATE_PARTICIPANT:
+                print_separator()
+                print(LABEL_CREATE_PARTICIPANT)
+                while True:
+                    first_name = input(PROMPT_FIRST_NAME).strip()
+                    if not re.fullmatch(r"[A-Za-zА-Яа-яЁё-]+", first_name):
+                        print(PARTICIPANT_NAME_RULE)
+                        continue
+                    break
+
+                while True:
+                    last_name = input(PROMPT_LAST_NAME).strip()
+                    if not re.fullmatch(r"[A-Za-zА-Яа-яЁё-]+", last_name):
+                        print(PARTICIPANT_LAST_NAME_RULE)
+                        continue
+                    break
+
+                while True:
+                    nickname = input(PROMPT_NICKNAME).strip()
+                    if not re.fullmatch(r"[A-Za-zА-Яа-яЁё-]+", nickname):
+                        print(PARTICIPANT_NICKNAME_RULE)
+                        continue
+                    break
+
+                while True:
+                    activity_rating_raw = input(PROMPT_ACTIVITY).strip()
+                    try:
+                        activity_rating = float(activity_rating_raw)
+                        if activity_rating < 0.1 or activity_rating > 5.0:
+                            print(ACTIVITY_RANGE_RULE)
+                            continue
+                    except ValueError:
+                        print(ACTIVITY_NUMBER_RULE)
+                        continue
+                    break
+
+                try:
+                    participant = client.create_participant(
+                        first_name, last_name, nickname, activity_rating
+                    )
+                    print(MSG_PARTICIPANT_CREATED)
+                    print(
+                        PARTICIPANT_CREATED_ID_TEMPLATE.format(id=participant["id"])
+                    )
+                except httpx.HTTPStatusError as e:
+                    print(
+                        MSG_ERROR_TEMPLATE.format(
+                            status=e.response.status_code, text=e.response.text
+                        )
+                    )
+
+            elif choice == MenuChoice.LIST_TOPICS:
+                print_separator()
+                print(LABEL_ALL_TOPICS)
+                try:
+                    topics = client.get_topics()
+                    print_topics(topics)
+                except httpx.HTTPStatusError as e:
+                    print(
+                        MSG_ERROR_TEMPLATE.format(
+                            status=e.response.status_code, text=e.response.text
+                        )
+                    )
+
+            elif choice == MenuChoice.LIST_MESSAGES:
+                print_separator()
+                print(LABEL_ALL_MESSAGES)
+                try:
+                    messages = client.get_messages()
+                    print_messages(messages)
+                except httpx.HTTPStatusError as e:
+                    print(
+                        MSG_ERROR_TEMPLATE.format(
+                            status=e.response.status_code, text=e.response.text
+                        )
+                    )
+
+            elif choice == MenuChoice.GET_TOPIC:
+                print_separator()
+                topic_id = input(PROMPT_TOPIC_ID).strip()
+                try:
+                    UUID(topic_id)
+                    topic = client.get_topic(topic_id)
+                    print_topic_detail(topic)
+                except ValueError:
+                    print(MSG_INVALID_UUID)
+                except httpx.HTTPStatusError as e:
+                    print(
+                        MSG_ERROR_TEMPLATE.format(
+                            status=e.response.status_code, text=e.response.text
+                        )
+                    )
+
+            elif choice == MenuChoice.CREATE_TOPIC:
+                print_separator()
+                print(LABEL_CREATE_TOPIC)
+                title = input(PROMPT_TITLE).strip()
+                description = input(PROMPT_DESCRIPTION).strip()
+                try:
+                    topic = client.create_topic(title, description)
+                    print(MSG_TOPIC_CREATED)
+                    print(TOPIC_CREATED_ID_TEMPLATE.format(id=topic["id"]))
+                except httpx.HTTPStatusError as e:
+                    print(
+                        MSG_ERROR_TEMPLATE.format(
+                            status=e.response.status_code, text=e.response.text
+                        )
+                    )
+
+            elif choice == MenuChoice.PUBLISH_MESSAGE:
+                print_separator()
+                print(LABEL_PUBLISH_MESSAGE)
+                while True:
+                    topic_id = input(PROMPT_TOPIC_ID_INLINE).strip()
+                    if not topic_id:
+                        print(MSG_TOPIC_ID_REQUIRED)
+                        continue
+                    try:
+                        client.get_topic(topic_id)
+                    except httpx.HTTPStatusError as e:
+                        if e.response.status_code in (404, 422):
+                            print(MSG_TOPIC_NOT_FOUND)
+                        else:
+                            print(
+                                MSG_ERROR_TEMPLATE.format(
+                                    status=e.response.status_code, text=e.response.text
+                                )
+                            )
+                        continue
+                    break
+                
+                while True:
+                    participant_id = input(PROMPT_PARTICIPANT_ID_INLINE).strip()
+                    if not participant_id:
+                        print(MSG_PARTICIPANT_ID_REQUIRED)
+                        continue
+                    try:
+                        client.get_participant(participant_id)
+                    except httpx.HTTPStatusError as e:
+                        if e.response.status_code in (404, 422):
+                            print(MSG_PARTICIPANT_NOT_FOUND)
+                        else:
+                            print(
+                                MSG_ERROR_TEMPLATE.format(
+                                    status=e.response.status_code, text=e.response.text
+                                )
+                            )
+                        continue
+                    break
+
+                content = input(PROMPT_MESSAGE_CONTENT).strip()
+
+                result = client.publish_message(topic_id, participant_id, content)
+                if isinstance(result, str):
+                    print(RESULT_MESSAGE_TEMPLATE.format(result=result))
+                else:
+                    print(MSG_MESSAGE_PUBLISHED)
+                    print(
+                        TOPIC_MESSAGES_COUNT_TEMPLATE.format(
+                            count=len(result["messages"])
+                        )
+                    )
+
+            else:
+                print(MSG_INVALID_OPTION)
+
+    except KeyboardInterrupt:
+        print(MSG_GOODBYE_INTERRUPT)
+    finally:
+        client.close()
+
+
+if __name__ == "__main__":
+    main()

data/messages.txt

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

data/participants.txt

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

data/topics.txt

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

main.py

@@ -0,0 +1,3 @@
+from app import create_app
+
+app = create_app()

requirements.txt

@@ -0,0 +1,23 @@
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anyio==4.11.0
+certifi==2025.11.12
+click==8.3.1
+fastapi==0.122.0
+h11==0.16.0
+httpcore==1.0.9
+httptools==0.7.1
+httpx==0.28.1
+idna==3.11
+pydantic==2.12.4
+pydantic_core==2.41.5
+python-dotenv==1.2.1
+PyYAML==6.0.3
+sniffio==1.3.1
+starlette==0.50.0
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+uvicorn==0.38.0
+uvloop==0.22.1
+watchfiles==1.1.1
+websockets==15.0.1