Source code for learn_sphinx.hello

import logging
from logging import FileHandler


def hello_world():
    """Say hello world"""


def hello(name):
    """asdasdas

    ======================     =========================  ========================================================
    :attr:`ord`                norm for matrices          norm for vectors
    ======================     =========================  ========================================================
    `None` (default)           Frobenius norm             `2`-norm (see below)
    `'fro'`                    Frobenius norm             -- not supported --
    `'nuc'`                    nuclear norm               -- not supported --
    `inf`                      `max(sum(abs(x), dim=1))`  `max(abs(x))`
    `-inf`                     `min(sum(abs(x), dim=1))`  `min(abs(x))`
    `0`                        -- not supported --        `sum(x != 0)`
    `1`                        `max(sum(abs(x), dim=0))`  as below
    `-1`                       `min(sum(abs(x), dim=0))`  as below
    `2`                        largest singular value     as below
    `-2`                       smallest singular value    as below
    other `int` or `float`     -- not supported --        `sum(abs(x)^{ord})^{(1 / ord)}`
    ======================     =========================  ========================================================
    """
    print(f'hello {name} ~')


logger_initialized = {}


def get_logger(name, log_file=None, log_level=logging.INFO, file_mode='w'):
    """Initialize and get a logger by name.

    If the logger has not been initialized, this method will initialize the
    logger by adding one or two handlers, otherwise the initialized logger will
    be directly returned. During initialization, a StreamHandler will always be
    added. If `log_file` is specified and the process rank is 0, a FileHandler
    will also be added.

    Args:
        name (str): Logger name.
        log_file (str | None): The log filename. If specified, a FileHandler
            will be added to the logger.
        log_level (int): The logger level. Note that only the process of
            rank 0 is affected, and other processes will set the level to
            "Error" thus be silent most of the time.
        file_mode (str): The file mode used in opening log file.
            Defaults to 'w'.

    Returns:
        logging.Logger: The expected logger.
    """
    logger = logging.getLogger(name)
    if name in logger_initialized:
        return logger
    # handle hierarchical names
    # e.g., logger "a" is initialized, then logger "a.b" will skip the
    # initialization since it is a child of "a".
    for logger_name in logger_initialized:
        if name.startswith(logger_name):
            return logger

    # handle duplicate logs to the console
    # Starting in 1.8.0, PyTorch DDP attaches a StreamHandler <stderr> (NOTSET)
    # to the root logger. As logger.propagate is True by default, this root
    # level handler causes logging messages from rank>0 processes to
    # unexpectedly show up on the console, creating much unwanted clutter.
    # To fix this issue, we set the root logger's StreamHandler, if any, to log
    # at the ERROR level.
    for handler in logger.root.handlers:
        if type(handler) is logging.StreamHandler:
            handler.setLevel(logging.ERROR)

    stream_handler = logging.StreamHandler()
    handlers = [stream_handler]

    # if dist.is_available() and dist.is_initialized():
    #     rank = dist.get_rank()
    # else:
    #     rank = 0
    rank = 0

    # only rank 0 will add a FileHandler
    if rank == 0 and log_file is not None:
        # Here, the default behaviour of the official logger is 'a'. Thus, we
        # provide an interface to change the file mode to the default
        # behaviour.
        file_handler = logging.FileHandler(log_file, file_mode)
        handlers.append(file_handler)

    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    for handler in handlers:
        handler.setFormatter(formatter)
        handler.setLevel(log_level)
        logger.addHandler(handler)

    if rank == 0:
        logger.setLevel(log_level)
    else:
        logger.setLevel(logging.ERROR)

    logger_initialized[name] = True

    return logger


def print_log(msg, logger=None, level=logging.INFO):
    """Print a log message.

    Examples:
        >>> print_log('hello')
        hello
        >>> get_logger('my_logger')
        >>> # Print message via `my_logger`.
        >>> print_log('hello', 'my_logger')
        2022-04-13 01:30:43,858 - my_logger - INFO - hello
        >>> print_log('hello', 'silent')
        >>> # Print no message.

    Note:
        If specified logger has not been created, :func:`print_log` will
        create a new logger without :obj:`FileHandler`.

    Warnings:
        FBI warning.

    Args:
        msg (str): The message to be logged.
        logger (logging.Logger | str | None): The logger to be used.
            Some special loggers are:

            ===========    ================================
            logger         meaning
            ===========    ================================
            "silent"       no message will be printed.
            other str      the logger obtained with ``get_root_logger(logger)``.
            None           The `print()` method will be used to print log messages.
            ===========    ================================
        level (int): Logging level. Only available when `logger` is a Logger
            object or "root".
    """
    if logger is None:
        print(msg)
    elif isinstance(logger, logging.Logger):
        logger.log(level, msg)
    elif logger == 'silent':
        pass
    elif isinstance(logger, str):
        _logger = get_logger(logger)
        _logger.log(level, msg)
    else:
        raise TypeError(
            'logger should be either a logging.Logger object, str, '
            f'"silent" or None, but got {type(logger)}')


def learn_math_render():
    r"""This is Normalize distribution
    :math:`\mathcal{N}(\text{mean}, \text{std}^2)`
    """
    print('learn_math_render')

from torch.nn.init import calculate_gain