feat: initial commit

config/__init__.py

@@ -0,0 +1,45 @@
+"""Configuration constants for the project."""
+
+from os import environ
+from os.path import join, exists, abspath, dirname
+
+import yaml
+from easydict import EasyDict
+
+
+def load_yaml(path: str) -> EasyDict:
+    """Load yaml file."""
+    with open(path, "r", encoding="utf8") as f:
+        config = yaml.safe_load(f)
+    return EasyDict(config)
+
+
+##################################################
+# Environments
+##################################################
+DEBUG = False
+ENV = environ.get("ENV", "dev")
+
+
+##################################################
+# PATH
+##################################################
+ROOT_DIR = abspath(dirname(dirname(__file__)))
+CONFIG_DIR = join(ROOT_DIR, "config")
+SERVICE_CONFIG_PATH = join(CONFIG_DIR, "service.yaml")
+if not exists(SERVICE_CONFIG_PATH):
+    SERVICE_CONFIG_PATH = join(CONFIG_DIR, "service.dev.yaml")
+ENGINE_CONFIG_PATH = join(CONFIG_DIR, "engine.yaml")
+
+
+##################################################
+# Configurations
+##################################################
+CFG_SERVICE = load_yaml(SERVICE_CONFIG_PATH)
+CFG_ENGINE = load_yaml(ENGINE_CONFIG_PATH)
+
+
+if __name__ == "__main__":
+    print(ENV)
+    print(CFG_SERVICE)
+    print(CFG_ENGINE)

pyproject.toml

@@ -0,0 +1,20 @@
+[tool.poetry]
+name = "bible-guidechat"
+version = "0.1.1"
+description = "Bible Guide Chat"
+authors = ["alchemine <djyoon0223@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+filterwarnings = [
+    "ignore::DeprecationWarning",
+]
+addopts = "--show-capture=no"

requirements.txt

@@ -1 +1,3 @@
-huggingface_hub==0.25.2
+huggingface_hub==0.25.2
+easydict==1.13
+pyyaml==6.0.2

src/common/__init__.py

@@ -0,0 +1,6 @@
+"""Commonly used package."""
+
+from src.common.global_settings import configure_global_settings
+
+
+configure_global_settings()

src/common/depth_logging.py

@@ -0,0 +1,80 @@
+"""DepthLogger class.
+
+Log depth of code.
+"""
+
+import contextlib
+from collections import defaultdict
+from functools import wraps
+
+from src.common.timer import Timer
+from src.common.logger import slog
+
+
+class DepthManager(contextlib.ContextDecorator):
+    """Code Depth Manager.
+
+    Attributes:
+        depth (int): Current depth of code
+        depths (dict): Depths of codes
+    """
+
+    depth = 1
+    depths = defaultdict(lambda: 1)
+
+    @classmethod
+    def __enter__(cls):
+        cls.depth += 1
+        return cls
+
+    @classmethod
+    def __exit__(cls, *exc):
+        cls.depths[cls.depth] = 1  # reset
+        cls.depth -= 1
+        cls.depths[cls.depth] += 1
+        return False
+
+
+def D(fn):
+    """Depth logging decorator.
+
+    Example:
+        >>> @D
+        >>> def f():
+        ...     # Depth: 1
+        ...     g()
+        >>> @D
+        >>> def g():
+        ...     # Depth: 2
+        ...     # do something
+    """
+
+    def _print_fn(name, args, fn):
+        """Print depth of code.
+
+        Args:
+            name (str): Function name
+            args (tuple): Arguments of the function
+            fn (callable): Function
+        """
+        logs = f"{'  ' + name:15}| "
+        if len(args) > 0 and isinstance(
+            args[0], object
+        ):  # if function is method or main function
+            logs = f"{logs}{fn.__module__.split('.')[-1]}."
+        slog(f"{logs}{fn.__name__}()")
+
+    @wraps(fn)
+    def _log(*args, **kwargs):
+        name = ".".join(
+            [str(DepthManager.depths[d]) for d in range(1, DepthManager.depth + 1)]
+        )
+        _print_fn(name, args, fn)
+
+        with DepthManager():
+            with Timer(name):
+                rst = fn(*args, **kwargs)
+
+        return rst
+
+    return _log

src/common/global_settings.py

@@ -0,0 +1,57 @@
+"""Global settings for the project.
+
+This module contains global configurations.
+It should be imported and run at the start of the project to ensure consistent settings across all modules.
+"""
+
+# import warnings
+
+# import numpy as np
+# import pandas as pd
+# import matplotlib.pyplot as plt
+# from pandas.plotting import register_matplotlib_converters
+
+
+def configure_global_settings() -> None:
+    """Configure global settings."""
+    pass
+    # from langchain_community.cache import InMemoryCache
+    # from langchain.globals import set_llm_cache
+
+    # set_llm_cache(InMemoryCache())
+
+    # # Warning
+    # warnings.filterwarnings("ignore")
+
+    # # Matplotlib settings
+    # register_matplotlib_converters()
+    # # plt.rc('font', family='NanumGothic')
+    # plt.rc("font", family="DejaVu Sans")
+    # plt.rc("axes", unicode_minus=False)
+    # plt.rc("font", size=20)
+    # plt.rc("figure", titlesize=40, titleweight="bold")
+    # plt.style.use("ggplot")
+
+    # # Numpy settings
+    # np.set_printoptions(
+    #     suppress=True,
+    #     precision=6,
+    #     edgeitems=20,
+    #     linewidth=100,
+    #     formatter={"float": lambda x: "{:.3f}".format(x)},
+    # )
+
+    # # Pandas settings
+    # pd.set_option("display.max_rows", 1000)
+    # pd.set_option("display.max_columns", 1000)
+    # pd.set_option("display.max_colwidth", 1000)
+    # pd.set_option("display.width", 1000)
+    # pd.set_option("display.float_format", "{:.2f}".format)
+
+
+# Optional: Add a function to reset to default settings if needed
+# def reset_to_default() -> None:
+#     """Reset to default settings."""
+#     plt.rcdefaults()
+#     np.set_printoptions()
+#     pd.reset_option("^display")

src/common/llm.py

@@ -0,0 +1,50 @@
+"""LLM module.
+
+# Proxy LLM
+LiteLLM can be used for LLM inference.
+- Model providers: https://docs.litellm.ai/docs/providers
+"""
+
+from langchain_core.messages import AIMessage
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+
+from config import CFG_ENGINE
+from src.common.logger import log_info
+from src.common.timer import T
+
+
+# Initialize ChatOpenAI client once at module level
+if CFG_ENGINE.inference.llm.use_proxy:
+    llm = ChatOpenAI(
+        model=CFG_ENGINE.inference.llm.model,
+        base_url=CFG_ENGINE.inference.llm.proxy.base_url,
+    )
+    embeddings = OpenAIEmbeddings()
+else:
+    llm = ChatOpenAI(model=CFG_ENGINE.inference.llm.model)
+    embeddings = OpenAIEmbeddings()
+
+
+@T
+def completion(messages: list[dict | tuple]) -> AIMessage:
+    """Get completion from LLM."""
+    response = llm.invoke(messages)
+
+    # Log metadata
+    log_info("Token usage:"), log_info(response.usage_metadata)
+    return response
+
+
+async def acompletion(messages: list[dict | tuple]) -> AIMessage:
+    """Get completion from LLM asynchronously."""
+    response = await llm.ainvoke(messages)
+
+    # Log metadata
+    log_info("Token usage:"), log_info(response.usage_metadata)
+    return response
+
+
+if __name__ == "__main__":
+    messages = [("user", "안녕! 네 이름이 뭐니?")]
+    response = completion(messages)
+    print(response.content)

src/common/loader.py

@@ -0,0 +1,25 @@
+"""Generic file handling functions."""
+
+from glob import glob
+from os.path import isfile, isdir
+
+import yaml
+from easydict import EasyDict
+
+
+############################################################
+# Lambda functions
+############################################################
+ls_all = lambda path: [path for path in glob(f"{path}/*")]
+ls_dir = lambda path: [path for path in glob(f"{path}/*") if isdir(path)]
+ls_file = lambda path: [path for path in glob(f"{path}/*") if isfile(path)]
+
+
+############################################################
+# File loading functions
+############################################################
+def load_yaml(path: str) -> EasyDict:
+    """Load yaml file."""
+    with open(path, "r") as f:
+        config = yaml.safe_load(f)
+    return EasyDict(config)

src/common/logger.py

@@ -0,0 +1,270 @@
+"""Logging module."""
+
+import re
+import json
+from datetime import datetime
+from pathlib import Path
+import logging
+from logging.handlers import TimedRotatingFileHandler
+
+
+# https://pkg.go.dev/github.com/shafiqaimanx/pastax/colors
+STYLES = {
+    "ENDC": "\033[0m",
+    "BOLD": "\033[1m",
+    "ITALIC": "\033[3m",
+    "UNDERLINE": "\033[4m",
+    "RED": "\033[31m",
+    "GREEN": "\033[32m",
+    "YELLOW": "\033[33m",
+    "BLUE": "\033[34m",
+    "MAGENTA": "\033[35m",
+    "CYAN": "\033[36m",
+    "DARKGRAY": "\033[90m",
+    "LIGHTRED": "\033[91m",
+    "PINK": "\033[95m",
+    "FIREBRICK": "\033[38;5;124m",
+    "ORANGERED": "\033[38;5;202m",
+    "TOMATO": "\033[38;5;203m",
+    "GRAPEFRUIT": "\033[38;5;208m",
+    "DARKORANGE": "\033[38;5;214m",
+    "OKRED": "\033[91m",
+    "OKGREEN": "\033[92m",
+    "OKYELLOW": "\033[93m",
+    "OKBLUE": "\033[94m",
+    "OKMAGENTA": "\033[95m",
+    "OKCYAN": "\033[96m",
+    None: "",
+}
+
+# With name version (for debugging)
+LOG_FORMAT = "%(asctime)s | %(name)-12s | %(levelname)-8s | %(message)s"
+# LOG_FORMAT = "%(asctime)s | %(levelname)-8s | %(message)s"
+LOG_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+
+class ANSIColorRemovingFormatter(logging.Formatter):
+    def format(self, record):
+        formatted = super().format(record)
+        return re.sub(r"\x1b\[[0-9;]*m", "", formatted)
+
+
+class TqdmLogger:
+    def write(self, message: str):
+        log_info(message.lstrip("\r\n"))
+
+    def flush(self):
+        pass
+
+
+def setup_advanced_logger(
+    logger_name: str = None,
+    log_level: str = "INFO",
+    log_format: str = LOG_FORMAT,
+    date_format: str = LOG_DATE_FORMAT,
+    log_to_console: bool = True,
+    log_to_file: bool = True,
+    log_dir: str = "logs",
+    file_rotation: str = "midnight",
+    file_backup_count: int = 7,
+) -> logging.Logger:
+    """
+    Setup an advanced logger with flexible configuration options.
+    Keeps colors in console output, removes them in file output.
+
+    Args:
+        logger_name (str): Name of the logger. If None, root logger is used.
+        log_level (str): Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL).
+        log_format (str): Format string for log messages.
+        date_format (str): Format string for timestamps in log messages.
+        log_to_console (bool): Whether to log to console.
+        log_to_file (bool): Whether to log to file.
+        log_dir (str): Directory to store log files.
+        log_file_prefix (str): Prefix for log file names.
+        file_rotation (str): When to rotate the log file (e.g., 'midnight', 'h' for hourly).
+        file_backup_count (int): Number of backup log files to keep.
+
+    Returns:
+        logging.Logger: Configured logger object.
+    """
+    # Create logger
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(getattr(logging, log_level.upper()))
+
+    # 기존 핸들러 제거
+    if logger.hasHandlers():
+        logger.handlers.clear()
+
+    # Create formatters
+    color_formatter = logging.Formatter(log_format, datefmt=date_format)
+    no_color_formatter = ANSIColorRemovingFormatter(log_format, datefmt=date_format)
+
+    # Console handler (with colors)
+    if log_to_console:
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(color_formatter)
+        logger.addHandler(console_handler)
+
+    # File handler (without colors)
+    if log_to_file:
+        log_dir_path = Path(log_dir)
+        log_dir_path.mkdir(parents=True, exist_ok=True)
+
+        current_date = datetime.now().strftime("%Y-%m-%d")
+        log_file_name = f"{current_date}.log"
+        log_file_path = log_dir_path / log_file_name
+
+        file_handler = TimedRotatingFileHandler(
+            filename=log_file_path,
+            when=file_rotation,
+            backupCount=file_backup_count,
+        )
+        file_handler.setFormatter(no_color_formatter)
+        file_handler.flush = lambda: file_handler.stream.flush()
+        logger.addHandler(file_handler)
+
+    return logger
+
+
+def pretty_dict(s: str) -> str:
+    """Pretty print dictionary.
+
+    Args:
+        s (str): The dictionary to pretty print.
+
+    Returns:
+        str: The pretty printed dictionary.
+    """
+    json_str = json.dumps(s, indent=2, ensure_ascii=False)
+    json_str = json_str.replace('\\"', "'")
+    return json_str
+
+
+def slog(
+    msg: str, style: str | None = None, level: str = "info", dump: bool = True, **kwargs
+) -> str:
+    """Stylish log message.
+
+    Args:
+        msg (str): The message to log.
+        style (str): The style of the message.
+        level (str): The log level.
+        dump (bool): The dump flag.
+
+    Returns:
+        str: The stylish message.
+    """
+    try:
+        if dump:
+            msg = pretty_dict(msg)
+            msg = msg.strip('"')  # remove redundant quotes
+    except:
+        pass
+
+    stylish_msg = f"{STYLES['BOLD']}{STYLES[style]}{msg}{STYLES['ENDC']}"
+    match level:
+        case "info":
+            logger.info(stylish_msg, **kwargs)
+        case "error":
+            logger.error(stylish_msg, **kwargs)
+        case "warning":
+            logger.warning(stylish_msg, **kwargs)
+        case "debug":
+            logger.debug(stylish_msg, **kwargs)
+        case _:
+            print(stylish_msg, **kwargs)
+
+    return stylish_msg
+
+
+def log_info(msg: str, dump: bool = True, **kwargs) -> str:
+    """Stylish info log.
+
+    Args:
+        msg (str): The message to log.
+        dump (bool): The dump flag. Defaults to True.
+    """
+    return slog(msg, style="GREEN", dump=dump, **kwargs)
+
+
+def log_success(msg: str, dump: bool = True, prefix: bool = True, **kwargs) -> str:
+    """Stylish success log.
+
+    Args:
+        msg (str): The message to log.
+        dump (bool): The dump flag. Defaults to True.
+        prefix (bool): The prefix flag. Defaults to True.
+    """
+    if prefix:
+        msg = f"[SUCCESS] {msg}"
+    return slog(msg, style="OKBLUE", dump=dump, **kwargs)
+
+
+def log_error(
+    msg: str,
+    dump: bool = False,
+    prefix: bool = True,
+    exc_info: Exception | None = None,
+    **kwargs,
+) -> str:
+    """Stylish error log.
+
+    Args:
+        msg (str): The message to log.
+        dump (bool): The dump flag. Defaults to True.
+    """
+    if prefix:
+        msg = f"[FAILED] {msg}"
+    return slog(
+        msg, style="TOMATO", level="error", dump=dump, exc_info=exc_info, **kwargs
+    )
+
+
+def log_warning(msg: str, dump: bool = False, prefix: bool = True, **kwargs) -> str:
+    """Stylish warning log.
+
+    Args:
+        msg (str): The message to log.
+        dump (bool): The dump flag. Defaults to True.
+    """
+    if prefix:
+        msg = f"[WARNING] {msg}"
+    return slog(msg, style="GRAPEFRUIT", level="warning", dump=dump, **kwargs)
+
+
+def log_api(msg: str, error: bool = False, **kwargs) -> None:
+    """Stylish api log.
+
+    Args:
+        msg (str): The message to log.
+        error (bool): The error status of the API. Defaults to False.
+    """
+    if error:
+        log_error("Request API:")
+        log_error(msg, dump=True)
+    else:
+        log_success("Request API:")
+        log_success(msg)
+
+
+# Setup default logger
+logger = setup_advanced_logger()
+
+
+# Disable logging for specific modules
+for name in ("elastic_transport.transport", "urllib3.connectionpool", "httpx"):
+    _logger = logging.getLogger(name)
+    _logger.setLevel(logging.ERROR)
+
+# Get tqdm file
+tqdm_file = TqdmLogger()
+
+
+if __name__ == "__main__":
+    log_info("This is an info message.")
+    log_success("This is a success message.")
+    log_error("This is an error message.")
+    log_warning("This is a warning message.")
+    log_api("This is an API message.")
+    for style in STYLES:
+        slog(f"This is a {style} message.", style=style)

src/common/requests.py

@@ -0,0 +1,145 @@
+"""Requests module for handling HTTP requests."""
+
+import asyncio
+from typing import Any
+
+import aiohttp
+import requests
+from requests import Response, RequestException
+
+from src.common.logger import log_api
+
+
+DEFAULT_HEADERS = {"accept": "application/json", "Content-Type": "application/json"}
+
+
+class APIError(Exception):
+    """API Error exception.
+
+    Args:
+        url (str): The URL of the API.
+        headers (dict): The headers of the API.
+        json (dict): The JSON data of the API.
+        response (Response): The response of the API.
+
+    Returns:
+        str: The API error message.
+    """
+
+    def __init__(self, url: str, headers: dict, json: dict, response: Response):
+        self.url = url
+        self.headers = headers
+        self.json = json
+        self.response = response
+
+    def __str__(self):
+        return f"""APIError: <Response [{self.response.status_code}]>
+requests.post(
+    url="{self.url}",
+    headers={self.headers},
+    json={self.json}
+) -> {self.response.json()}"""
+
+
+def get_request_log(
+    url: str, headers: dict, json: dict, response: Response | None = None
+) -> dict:
+    """Get the request log.
+
+    Args:
+        url (str): The URL of the API.
+        headers (dict): The headers of the API.
+        json (dict): The JSON data of the API.
+        response (Response): The response of the API.
+
+    Returns:
+        dict: The request log.
+    """
+    log = dict(
+        url=url,
+        headers=headers,
+        json=json,
+        reproduction_code=f"import requests; requests.post(url='{url}', headers={headers}, json={json})",
+    )
+
+    if response:
+        log.update(
+            response=dict(status_code=response.status_code, json=response.json())
+        )
+
+    return log
+
+
+def safe_request(url: str, json: dict, headers: dict = DEFAULT_HEADERS) -> dict:
+    """Requests with validation.
+
+    Args:
+        url (str): The URL of the API.
+        json (dict): The JSON data of the API.
+        headers (dict): The headers of the API.
+
+    Returns:
+        Response: The response of the API.
+    """
+    # Check the API communication validness
+    try:
+        response = requests.post(url=url, headers=headers, json=json)
+        response.raise_for_status()
+        log = get_request_log(url, headers, json)
+        log_api(log)
+        return response.json()
+    except RequestException as e:
+        log = get_request_log(url, headers, json)
+        log_api(log, error=True)
+        raise APIError(url, headers, json, response)
+
+
+async def async_safe_request(
+    session: aiohttp.ClientSession,
+    url: str,
+    data: dict,
+    headers: dict = DEFAULT_HEADERS,
+) -> list | dict:
+    """Post request using aiohttp.
+
+    Args:
+        session (aiohttp.ClientSession): aiohttp session.
+        url (str): URL to post.
+        data (dict): Data to post.
+        headers (dict): The headers of the API.
+
+    Returns:
+        list | dict: Response data.
+    """
+    async with session.post(
+        url=url,
+        headers=headers,
+        json=data,
+    ) as response:
+        response.raise_for_status()
+        return await response.json()
+
+
+async def async_safe_requests(batch: list[dict]) -> list[Any]:
+    """Post requests asynchronously.
+
+    Args:
+        batch (list[dict]): List of data to post.
+
+    Returns:
+        list[Any]: List of response data.
+
+    Examples:
+        import asyncio
+        asyncio.run(async_safe_requests(batch))
+    """
+    async with aiohttp.ClientSession() as session:
+        futures = [async_safe_request(session, **input) for input in batch]
+        responses = await asyncio.gather(*futures)
+    return responses
+
+
+if __name__ == "__main__":
+    url = "https://httpbin.org/post"
+    json = {"key": "value"}
+    response = safe_request(url, json)

src/common/timer.py

@@ -0,0 +1,52 @@
+"""Timer class.
+
+Context and decorator form timer.
+"""
+
+import contextlib
+from functools import wraps
+from time import perf_counter
+
+from src.common.logger import log_success, log_info
+
+
+class Timer(contextlib.ContextDecorator):
+    """Timer.
+
+    Examples:
+        >>> with Timer('Code1'):
+        ...     sleep(1)
+        * Code1        | 1.00s (0.02m)
+    """
+
+    def __init__(self, name="Elapsed time"):
+        self.name = name
+
+    def __enter__(self):
+        log_info(f"{'[START] ' + self.name:15}")
+        self.start_time = perf_counter()
+        return self
+
+    def __exit__(self, *exc):
+        elapsed_time = perf_counter() - self.start_time
+        log_success(f"{self.name:15} | {elapsed_time:.2f}s ({elapsed_time/60:.2f}m)")
+        return False
+
+
+def T(fn: callable) -> callable:
+    """Timer decorator.
+
+    Example:
+        >>> @T
+        >>> def f():
+        ...     sleep(1)
+        * Elapsed time | 1.00s (0.02m)
+    """
+
+    @wraps(fn)
+    def _log(*args, **kwargs):
+        with Timer(fn.__name__):
+            rst = fn(*args, **kwargs)
+        return rst
+
+    return _log

src/common/utils.py

@@ -0,0 +1,80 @@
+"""Utility module.
+
+Commonly used functions and classes are here.
+"""
+
+from datetime import datetime
+
+from src.common.logger import log_info
+
+
+vars_ = lambda obj: {k: v for k, v in vars(obj).items() if not k.startswith("__")}
+str2dt = lambda s, format="%Y-%m-%d": datetime.strptime(s, format)
+dt2str = lambda dt, format="%Y-%m-%d": dt.strftime(format)
+
+
+def lmap(fn: callable, arr: list, scheduler: str | None = None) -> list:
+    """List map.
+
+    Args:
+        fn (callable): Function to apply
+        arr (list): List to apply function
+        scheduler (str, optional): Dask scheduler. Defaults to None.
+            - None | "single-threaded": Single-threaded
+            - "threads": Multi-threaded
+            - "processes": Multi-process
+
+    Returns:
+        list: List of results
+    """
+    if scheduler is None:
+        return list(map(fn, arr))
+    else:
+        from dask import delayed, compute
+
+        assert scheduler in [
+            "single-threaded",
+            "threads",
+            "processes",
+        ], f"Invalid scheduler: {scheduler}"
+        tasks = (delayed(fn)(e) for e in arr)
+        return list(compute(*tasks, scheduler=scheduler))
+
+
+def tprint(dic: dict) -> None:
+    """Table print."""
+    import tabulate
+
+    # print with fancy 'psql' format
+    log_info(tabulate(dic, headers="keys", tablefmt="psql"))
+
+
+def str2bool(s: str | bool) -> bool:
+    """String to boolean."""
+    if isinstance(s, bool):
+        return s
+    if s.lower() in ("yes", "true", "t", "y", "1"):
+        return True
+    elif s.lower() in ("no", "false", "f", "n", "0"):
+        return False
+    else:
+        raise ValueError(f"Invalid input: {s} (type: {type(s)})")
+
+
+class MetaSingleton(type):
+    """Meta singleton.
+
+    Example:
+        >>> class A(metaclass=MetaSingleton):
+        ...     pass
+        >>> a1 = A()
+        >>> a2 = A()
+        >>> assert a1 is a2
+    """
+
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(MetaSingleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]

src/launch.py

@@ -0,0 +1,47 @@
+from time import sleep
+
+from src.common.timer import T
+from src.common.depth_logging import D
+
+
+@D
+def main():
+
+    main1()
+    main2()
+
+
+@D
+def main1():
+    main11()
+    main12()
+
+
+@D
+def main11():
+    return
+
+
+@D
+def main12():
+    return
+
+
+@D
+def main2():
+    main21()
+
+
+@D
+def main21():
+    return
+
+
+@T
+def f():
+    sleep(1)
+
+
+if __name__ == "__main__":
+    main()
+    f()