feat: add main

Author: emptybutton

deploy/dev/docker-compose.yaml

@@ -12,9 +12,11 @@ services:
     volumes:
       - ../..:/app
       - tgdb-data:/run/app
-    environments:
+    environment:
       CONF_PATH: /app/deploy/dev/tgdb/conf.yaml
-    command: bash
+    ports:
+      - 8000:8000
+    command: tgdb-dev
 
 volumes:
   tgdb-data: null

deploy/dev/tgdb/conf.yaml

@@ -1,11 +1,15 @@
 conf:
+  uvicorn:
+    host: "0.0.0.0"
+    port: 8000
+
   api:
     id: 23598539
     hash: "6d9d7305ffc6f148dab120d24541b127"
 
   clients:
-    bots: "/app/deploy/dev/tgdb/bots/bots.txt"
-    userbots: "/app/deploy/dev/tgdb/bots/userbots.txt"
+    bots: "/app/deploy/dev/tgdb/clients/bots.txt"
+    userbots: "/app/deploy/dev/tgdb/clients/userbots.txt"
 
   horizon:
     max_len: 10_000

pyproject.toml

@@ -25,6 +25,7 @@ Repository = "https://github.com/emptybutton/tgdb"
 [project.optional-dependencies]
 dev = [
     "mypy[faster-cache]==1.15.0",
+    "types-pyyaml==6.0.12.20250516",
     "ruff==0.9.7",
     "pytest==8.3.4",
     "pytest-cov==6.0.0",
@@ -43,6 +44,10 @@ build-backend = "hatchling.build"
 [tool.hatch.build.targets.wheel]
 packages = ["src/tgdb"]
 
+[project.scripts]
+tgdb = "tgdb.main.prod_server.__main__:main"
+tgdb-dev = "tgdb.main.dev_server.__main__:main"
+
 [tool.mypy]
 mypy_path = "$MYPY_CONFIG_FILE_DIR/src:$MYPY_CONFIG_FILE_DIR/tests"
 strict = true

src/tgdb/__init__.py

@@ -0,0 +1,4 @@
+from importlib.metadata import version
+
+
+__version__ = version("tgdb")

src/tgdb/infrastructure/pyyaml/conf.py

@@ -1,10 +1,14 @@
-from dataclasses import dataclass
 from pathlib import Path
 
 import yaml
 from pydantic import BaseModel, Field
 
 
+class UvicornConf(BaseModel):
+    host: str
+    port: int
+
+
 class APIConf(BaseModel):
     id: int
     hash: str
@@ -60,6 +64,7 @@ class BufferConf(BaseModel):
 
 
 class Conf(BaseModel):
+    uvicorn: UvicornConf
     api: APIConf
     clients: ClientsConf
     horizon: HorizonConf

src/tgdb/infrastructure/telethon/client_pool.py

@@ -8,9 +8,12 @@
 from typing import Self, cast
 
 from telethon import TelegramClient
-from telethon.sessions.string import StringSession
 from telethon.types import InputPeerUser
 
+from tgdb.infrastructure.telethon.string_session_without_entites import (
+    StringSessionWithoutEntites,
+)
+
 
 @dataclass(frozen=True, unsafe_hash=False)
 class TelegramClientPool(AbstractAsyncContextManager["TelegramClientPool"]):
@@ -21,6 +24,11 @@ class TelegramClientPool(AbstractAsyncContextManager["TelegramClientPool"]):
     )
 
     async def __aenter__(self) -> Self:
+        await gather(*(
+            client.__aenter__()  # type: ignore[no-untyped-call]
+            for client in self._clients
+        ))
+
         for client in self._clients:
             client_info = (
                 cast(InputPeerUser, await client.get_me(input_peer=True))
@@ -29,11 +37,6 @@ async def __aenter__(self) -> Self:
 
             self._client_by_id[client_id] = client
 
-        await gather(*(
-            client.__aenter__()  # type: ignore[no-untyped-call]
-            for client in self._clients
-        ))
-
         return self
 
     async def __aexit__(
@@ -71,12 +74,19 @@ def loaded_client_pool_from_farm_file(
 ) -> TelegramClientPool:
     with farm_file_path.open() as farm_file:
         return TelegramClientPool(deque(
-            TelegramClient(
-                StringSession(session_token),
-                app_api_id,
-                app_api_hash,
-                entity_cache=None,
-            )
+            pool_client(session_token, app_api_id, app_api_hash)
             for session_token in farm_file
             if session_token
         ))
+
+
+def pool_client(
+    session_token: str, app_api_id: int, app_api_hash: str
+) -> TelegramClient:
+    print(session_token)
+    return TelegramClient(
+        StringSessionWithoutEntites(session_token),
+        app_api_id,
+        app_api_hash,
+        entity_cache_limit=0,
+    )

src/tgdb/infrastructure/telethon/string_session_without_entites.py

@@ -0,0 +1,8 @@
+from typing import Any
+
+from telethon.sessions.string import StringSession
+
+
+class StringSessionWithoutEntites(StringSession):
+    def process_entities(self, tlo: Any) -> None:  # noqa: ANN401
+        ...

src/tgdb/main/common/di.py

@@ -24,6 +24,7 @@
 from tgdb.application.view_tuples import ViewTuples
 from tgdb.entities.horizon.horizon import Horizon, horizon
 from tgdb.entities.horizon.transaction import PreparedCommit
+from tgdb.entities.relation.relation import Relation
 from tgdb.infrastructure.adapters.buffer import (
     InMemoryBuffer,
     InTelegramReplicablePreparedCommitBuffer,
@@ -35,6 +36,7 @@
 from tgdb.infrastructure.adapters.shared_horizon import InMemorySharedHorizon
 from tgdb.infrastructure.adapters.tuples import InTelegramHeapTuples
 from tgdb.infrastructure.adapters.uuids import UUIDs4
+from tgdb.infrastructure.async_map import AsyncMap
 from tgdb.infrastructure.async_queque import AsyncQueque
 from tgdb.infrastructure.pyyaml.conf import Conf, VacuumConf
 from tgdb.infrastructure.telethon.client_pool import (
@@ -54,6 +56,8 @@
 BotPool = NewType("BotPool", TelegramClientPool)
 UserBotPool = NewType("UserBotPool", TelegramClientPool)
 
+RelationCache = NewType("RelationCache", InMemoryDb[Relation])
+
 
 def conf_vacuum(
     conf: VacuumConf, bot_pool: BotPool, user_bot_pool: UserBotPool
@@ -73,12 +77,12 @@ class CommonProvider(Provider):
     provide_clock = provide(PerfCounterClock, provides=Clock, scope=Scope.APP)
     provide_uuids = provide(UUIDs4, provides=UUIDs, scope=Scope.APP)
     provide_queque = provide(
-        lambda: InMemoryQueque(AsyncQueque()),
+        staticmethod(lambda: InMemoryQueque(AsyncQueque())),
         provides=Queque[Sequence[PreparedCommit]],
         scope=Scope.APP
     )
     provide_channel = provide(
-        AsyncMapChannel,
+        staticmethod(lambda: AsyncMapChannel(AsyncMap())),
         provides=Channel,
         scope=Scope.APP,
     )
@@ -174,20 +178,24 @@ def provide_buffer(
 
         return InTelegramReplicablePreparedCommitBuffer(buffer, in_tg_bytes)
 
+    @provide(scope=Scope.APP)
+    def provide_relation_cache(self) -> RelationCache:
+        return RelationCache(InMemoryDb())
+
     @provide(scope=Scope.APP)
     def provide_relations(
         self,
         conf: Conf,
         bot_pool: BotPool,
         user_bot_pool: UserBotPool,
+        relation_cache: RelationCache,
     ) -> Relations:
         autovacuum = conf_vacuum(conf.relations.vacuum, bot_pool, user_bot_pool)
         in_tg_bytes = InTelegramBytes(
             bot_pool, user_bot_pool, conf.relations.chat, autovacuum
         )
-        cached_relations = InMemoryDb()
 
-        return InTelegramReplicableRelations(in_tg_bytes, cached_relations)
+        return InTelegramReplicableRelations(in_tg_bytes, relation_cache)
 
     provide_commit_transaction = provide(CommitTransaction, scope=Scope.APP)
     provide_output_commits = provide(OutputCommits, scope=Scope.APP)

src/tgdb/main/dev_server/__init__.py

@@ -0,0 +1,31 @@
+import asyncio
+
+import uvicorn
+
+from tgdb.infrastructure.pyyaml.conf import Conf
+from tgdb.main.server.di import server_container
+from tgdb.presentation.fastapi.common.app import app_from
+
+
+async def amain() -> None:
+    app = await app_from(server_container)
+    conf = await server_container.get(Conf)
+
+    config = uvicorn.Config(
+        app,
+        host=conf.uvicorn.host,
+        port=conf.uvicorn.port,
+        reload=True,
+        reload_dirs=["/app"],
+    )
+    server = uvicorn.Server(config)
+
+    await server.serve()
+
+
+def main() -> None:
+    asyncio.run(amain())
+
+
+if __name__ == "__main__":
+    main()