ref(conf): rename configs withot abbreviations

Author: emptybutton

src/tgdb/infrastructure/pyyaml/conf.py

@@ -0,0 +1,74 @@
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class UvicornConfig(BaseModel):
+    host: str
+    port: int
+
+
+class APIConfig(BaseModel):
+    id: int
+    hash: str
+
+
+class ClientsConfig(BaseModel):
+    bots: Path
+    userbots: Path
+
+
+class TransactionConfig(BaseModel):
+    max_age_seconds: int = Field(..., alias="max_age_seconds")
+
+
+class HorizonConfig(BaseModel):
+    max_len: int
+    transaction: TransactionConfig
+
+
+class MessageCacheConfig(BaseModel):
+    max_len: int
+
+
+class PageConfig(BaseModel):
+    fullness: float
+
+
+class HeapConfig(BaseModel):
+    chat: int
+    page: PageConfig
+
+
+class RelationsConfig(BaseModel):
+    chat: int
+
+
+class OverflowConfig(BaseModel):
+    len: int
+    timeout_seconds: int | float
+
+
+class BufferConfig(BaseModel):
+    chat: int
+    overflow: OverflowConfig
+
+
+class TgdbConfig(BaseModel):
+    uvicorn: UvicornConfig
+    api: APIConfig
+    clients: ClientsConfig
+    horizon: HorizonConfig
+    message_cache: MessageCacheConfig
+    heap: HeapConfig
+    relations: RelationsConfig
+    buffer: BufferConfig
+
+    @classmethod
+    def load(cls, path: Path) -> "TgdbConfig":
+        with path.open() as file:
+            data = yaml.safe_load(file)
+
+        conf = data["conf"]
+        return TgdbConfig(**conf)

src/tgdb/infrastructure/pyyaml/config.py

@@ -38,7 +38,7 @@
 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
+from tgdb.infrastructure.pyyaml.config import TgdbConfig
 from tgdb.infrastructure.telethon.client_pool import (
     TelegramClientPool,
     loaded_client_pool_from_farm_file,
@@ -62,8 +62,8 @@ class MainIOProvider(Provider):
     provide_envs = provide(Envs.load, scope=Scope.APP)
 
     @provide(scope=Scope.APP)
-    def provide_conf(self, envs: Envs) -> Conf:
-        return Conf.load(envs.conf_path)
+    def provide_conf(self, envs: Envs) -> TgdbConfig:
+        return TgdbConfig.load(envs.conf_path)
 
 
 class CommonProvider(Provider):
@@ -81,33 +81,35 @@ class CommonProvider(Provider):
     )
 
     @provide(scope=Scope.APP)
-    async def provide_bot_pool(self, conf: Conf) -> AsyncIterator[BotPool]:
+    async def provide_bot_pool(
+        self, config: TgdbConfig
+    ) -> AsyncIterator[BotPool]:
         pool = BotPool(loaded_client_pool_from_farm_file(
-            conf.clients.bots,
-            conf.api.id,
-            conf.api.hash,
+            config.clients.bots,
+            config.api.id,
+            config.api.hash,
         ))
         async with pool:
             yield pool
 
     @provide(scope=Scope.APP)
     async def provide_userbot_pool(
-        self, conf: Conf
+        self, config: TgdbConfig
     ) -> AsyncIterator[UserBotPool]:
         pool = UserBotPool(loaded_client_pool_from_farm_file(
-            conf.clients.userbots,
-            conf.api.id,
-            conf.api.hash,
+            config.clients.userbots,
+            config.api.id,
+            config.api.hash,
         ))
         async with pool:
             yield pool
 
     @provide(scope=Scope.APP)
-    def provide_horizon(self, conf: Conf) -> Horizon:
+    def provide_horizon(self, config: TgdbConfig) -> Horizon:
         return horizon(
             0,
-            conf.horizon.max_len,
-            int(conf.horizon.transaction.max_age_seconds * 1_000_000_000),
+            config.horizon.max_len,
+            int(config.horizon.transaction.max_age_seconds * 1_000_000_000),
         )
 
     @provide(scope=Scope.APP)
@@ -118,25 +120,27 @@ def provide_shared_horizon(self, horizon: Horizon) -> SharedHorizon:
     def provide_lazy_message_map(
         self,
         user_bot_pool: UserBotPool,
-        conf: Conf,
+        config: TgdbConfig,
     ) -> MessageIndexLazyMap:
-        return message_index_lazy_map(user_bot_pool, conf.message_cache.max_len)
+        return message_index_lazy_map(
+            user_bot_pool, config.message_cache.max_len
+        )
 
     @provide(scope=Scope.APP)
     def provide_in_telegram_heap(
         self,
         bot_pool: BotPool,
         user_bot_pool: UserBotPool,
-        conf: Conf,
+        config: TgdbConfig,
         message_index_lazy_map: MessageIndexLazyMap,
     ) -> InTelegramHeap:
         return InTelegramHeap(
             bot_pool,
             user_bot_pool,
             bot_pool,
             bot_pool,
-            conf.heap.chat,
-            InTelegramHeap.encoded_tuple_max_len(conf.heap.page.fullness),
+            config.heap.chat,
+            InTelegramHeap.encoded_tuple_max_len(config.heap.page.fullness),
             message_index_lazy_map,
         )
 
@@ -149,23 +153,25 @@ def provide_in_telegram_heap(
     @provide(scope=Scope.APP)
     def provide_in_memory_buffer[ValueT](
         self,
-        conf: Conf,
+        config: TgdbConfig,
     ) -> InMemoryBuffer[ValueT]:
         return InMemoryBuffer(
-           conf.buffer.overflow.len,
-           conf.buffer.overflow.timeout_seconds,
+           config.buffer.overflow.len,
+           config.buffer.overflow.timeout_seconds,
            deque(),
         )
 
     @provide(scope=Scope.APP)
     async def provide_buffer(
         self,
-        conf: Conf,
+        config: TgdbConfig,
         bot_pool: BotPool,
         user_bot_pool: UserBotPool,
         buffer: InMemoryBuffer[Commit | PreparedCommit]
     ) -> AsyncIterator[Buffer[Commit | PreparedCommit]]:
-        in_tg_bytes = InTelegramBytes(bot_pool, user_bot_pool, conf.buffer.chat)
+        in_tg_bytes = InTelegramBytes(
+            bot_pool, user_bot_pool, config.buffer.chat
+        )
 
         biffer = InTelegramReplicablePreparedCommitBuffer(buffer, in_tg_bytes)
 
@@ -179,13 +185,13 @@ def provide_relation_cache(self) -> RelationCache:
     @provide(scope=Scope.APP)
     async def provide_relations(
         self,
-        conf: Conf,
+        config: TgdbConfig,
         bot_pool: BotPool,
         user_bot_pool: UserBotPool,
         relation_cache: RelationCache,
     ) -> AsyncIterator[Relations]:
         in_tg_bytes = InTelegramBytes(
-            bot_pool, user_bot_pool, conf.relations.chat
+            bot_pool, user_bot_pool, config.relations.chat
         )
         relations = InTelegramReplicableRelations(in_tg_bytes, relation_cache)
 

src/tgdb/main/common/di.py

@@ -1,11 +1,11 @@
 import uvicorn
 
-from tgdb.infrastructure.pyyaml.conf import Conf
+from tgdb.infrastructure.pyyaml.config import TgdbConfig
 from tgdb.main.common.di import main_io_container
 
 
 def main() -> None:
-    tgdb_config = main_io_container.get(Conf)
+    tgdb_config = main_io_container.get(TgdbConfig)
 
     uvicorn.run(
         "tgdb.main.dev_server.asgi:app",

src/tgdb/main/dev_server/__main__.py

@@ -2,14 +2,14 @@
 
 import uvicorn
 
-from tgdb.infrastructure.pyyaml.conf import Conf
+from tgdb.infrastructure.pyyaml.config import TgdbConfig
 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)
-    tgdb_config = await server_container.get(Conf)
+    tgdb_config = await server_container.get(TgdbConfig)
 
     uvicorn_config = uvicorn.Config(
         app,

src/tgdb/main/prod_server/__main__.py

@@ -10,12 +10,12 @@
 from tgdb.entities.numeration.number import Number
 from tgdb.entities.relation.scalar import Scalar
 from tgdb.entities.relation.tuple import Tuple
-from tgdb.presentation.fastapi.relation.schemas.error import NoRelationSchema
 from tgdb.presentation.fastapi.common.tags import Tag
 from tgdb.presentation.fastapi.horizon.schemas.error import (
     NoTransactionSchema,
     TransactionCommittingSchema,
 )
+from tgdb.presentation.fastapi.relation.schemas.error import NoRelationSchema
 from tgdb.presentation.fastapi.relation.schemas.tuple import TupleSchema
 
 

src/tgdb/presentation/fastapi/relation/routes/view_tuples.py

@@ -0,0 +1,7 @@
+from pathlib import Path
+
+from tgdb.infrastructure.pyyaml.config import TgdbConfig
+
+
+def test_no_errors() -> None:
+    TgdbConfig.load(Path("deploy/dev/tgdb/conf.yaml"))