apex/validator.py at main · elmusatii/apex · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
import argparse
import asyncio
from pathlib import Path

from loguru import logger

from apex import __version__
from apex.common.async_chain import AsyncChain
from apex.common.config import Config

# from apex.services.deep_research.deep_research_langchain import DeepResearchLangchain
# from apex.services.llm.llm import LLM
# from apex.services.websearch.websearch_tavily import WebSearchTavily
# from apex.validator.logger_db import LoggerDB
# from apex.validator.logger_wandb import LoggerWandb
# from apex.validator.miner_sampler import MinerSampler
from apex.validator.miner_scorer import MinerScorer

# from apex.validator.pipeline import Pipeline
# from apex.validator.weight_syncer import WeightSyncer


async def read_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Apex validator")
    parser.add_argument(
        "-c",
        "--config",
        # default="config/testnet.yaml",
        default="config/mainnet.yaml",
        help="Config file path (e.g. config/mainnet.yaml).",
        type=Path,
    )
    args = parser.parse_args()
    return args


async def main() -> None:
    args = await read_args()
    config = Config.from_file(path=args.config)
    logger.debug(f"Starting validator v{__version__} with config: {args.config}")

    chain = AsyncChain(**config.chain.kwargs)
    await chain.start()
    logger.debug(
        f"Connected to the chain netuid={chain.netuid} with coldkey '{chain.coldkey[:2]}***', "
        f"hotkey '{chain.hotkey[:2]}***'"
    )

    miner_scorer = MinerScorer(chain=chain, weight_syncer=None, **config.miner_scorer.kwargs)
    asyncio.create_task(miner_scorer.start_loop())

    logger.debug("Starting validator with full burn mode")
    try:
        while True:
            await asyncio.sleep(60)
    except KeyboardInterrupt:
        logger.warning("Keyboard interrupt caught, exiting validator")
    except BaseException as exc:
        logger.exception(f"Unknown exception caught, exiting validator: {exc}")
    finally:
        await chain.shutdown()
        await miner_scorer.shutdown()

    # weight_syncer = WeightSyncer(chain=chain, **config.weight_syncer.kwargs)
    # await weight_syncer.start()
    # logger.debug(
    #     f"Started weight synchronizer, receive enabled: {weight_syncer.receive_enabled}, "
    #     f"send enabled: {weight_syncer.send_enabled}, port: {weight_syncer.port}"
    # )

    # logger_db = LoggerDB(**config.logger_db.kwargs)
    # asyncio.create_task(logger_db.start_loop())
    # logger.debug(f"Started DB at: '{logger_db.db_path}'")

    # logger_wandb = LoggerWandb(async_chain=chain, **config.logger_wandb.kwargs)

    # websearch = WebSearchTavily(**config.websearch.kwargs)
    # logger.debug("Started web search tool")

    # miner_sampler = MinerSampler(chain=chain, logger_db=logger_db, **config.miner_sampler.kwargs)
    # logger.debug("Started miner sampler")

    # llm = LLM(**config.llm.kwargs)
    # logger.debug("Started LLM provider")

    # deep_research = DeepResearchLangchain(websearch=websearch, **config.deep_research.kwargs)
    # logger.debug("Started Deep Researcher")

    # pipeline = Pipeline(
    #     websearch=websearch,
    #     miner_sampler=miner_sampler,
    #     llm=llm,
    #     deep_research=deep_research,
    #     logger_wandb=logger_wandb,
    #     **config.pipeline.kwargs,
    # )
    # try:
    #     logger.debug("Starting pipeline loop...")
    #     await pipeline.start_loop()
    # except KeyboardInterrupt:
    #     logger.warning("Keyboard interrupt caught, exiting validator")
    # except BaseException as exc:
    #     logger.exception(f"Unknown exception caught, exiting validator: {exc}")
    # finally:
    #     await chain.shutdown()
    #     await logger_db.shutdown()
    #     await miner_scorer.shutdown()
    #     await weight_syncer.shutdown()


if __name__ == "__main__":
    asyncio.run(main())