cxppython 0.0.1__tar.gz → 0.0.3__tar.gz

{cxppython-0.0.1 → cxppython-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cxppython
-Version: 0.0.1
+Version: 0.0.3
 Summary: A python utils package
 Home-page: https://github.com/yourusername/my_package
 Author: cxp
@@ -25,3 +25,10 @@ Dynamic: requires-python
 Dynamic: summary
 
 # cxppython
+### install build
+- python -m pip install --upgrade pip setuptools wheel twine
+- 
+### build
+- python setup.py sdist bdist_wheel
+### upload
+- twine upload dist/*

cxppython-0.0.3/README.md

@@ -0,0 +1,8 @@
+# cxppython
+### install build
+- python -m pip install --upgrade pip setuptools wheel twine
+- 
+### build
+- python setup.py sdist bdist_wheel
+### upload
+- twine upload dist/*

cxppython-0.0.3/cxppython/__init__.py

@@ -0,0 +1,3 @@
+from .utils.btlogging import logging
+from .utils.easy_imports import *
+from .utils.database import db

cxppython-0.0.3/cxppython/core/config.py

@@ -0,0 +1,248 @@
+"""Implementation of the config class, which manages the configuration of different Bittensor modules.
+
+Example:
+    import argparse
+    import bittensor as bt
+
+    parser = argparse.ArgumentParser('Miner')
+    bt.Axon.add_args(parser)
+    bt.Subtensor.add_args(parser)
+    bt.Async_subtensor.add_args(parser)
+    bt.Wallet.add_args(parser)
+    bt.logging.add_args(parser)
+    bt.PriorityThreadPoolExecutor.add_args(parser)
+    config = bt.config(parser)
+
+    print(config)
+"""
+
+import argparse
+import os
+import sys
+from copy import deepcopy
+from typing import Any, TypeVar, Type, Optional
+
+import yaml
+from munch import DefaultMunch
+
+
+def _filter_keys(obj):
+    """Filters keys from an object, excluding private and certain internal properties."""
+    if isinstance(obj, dict):
+        return {
+            k: _filter_keys(v)
+            for k, v in obj.items()
+            if not k.startswith("__") and not k.startswith("_Config__is_set")
+        }
+    elif isinstance(obj, (Config, DefaultMunch)):
+        return _filter_keys(obj.toDict())
+    return obj
+
+
+class InvalidConfigFile(Exception):
+    """Raised when there's an error loading the config file."""
+
+
+class Config(DefaultMunch):
+    """Manages configuration for Bittensor modules with nested namespace support."""
+
+    def __init__(
+        self,
+        parser: argparse.ArgumentParser = None,
+        args: Optional[list[str]] = None,
+        strict: bool = False,
+        default: Any = None,
+    ) -> None:
+        super().__init__(default)
+        self.__is_set = {}
+
+        if parser is None:
+            return
+
+        self._add_default_arguments(parser)
+        args = args or sys.argv[1:]
+        self._validate_required_args(parser, args)
+
+        config_params = self._parse_args(args, parser, strict=False)
+        config_path = self._get_config_path(config_params)
+        strict = strict or getattr(config_params, "strict", False)
+
+        if config_path:
+            self._load_config_file(parser, config_path)
+
+        params = self._parse_args(args, parser, strict)
+        self._build_config_tree(params)
+        self._detect_set_parameters(parser, args)
+
+    def __str__(self) -> str:
+        """String representation without private keys, optimized to avoid deepcopy."""
+        cleaned = _filter_keys(self.toDict())
+        return "\n" + yaml.dump(cleaned, sort_keys=False, default_flow_style=False)
+
+    def __repr__(self) -> str:
+        """String representation of the Config."""
+        return self.__str__()
+
+    def _validate_required_args(
+        self, parser: argparse.ArgumentParser, args: list[str]
+    ) -> None:
+        """Validates required arguments are present."""
+        missing = self._find_missing_required_args(parser, args)
+        if missing:
+            raise ValueError(f"Missing required arguments: {', '.join(missing)}")
+
+    def _find_missing_required_args(
+        self, parser: argparse.ArgumentParser, args: list[str]
+    ) -> list[str]:
+        """Identifies missing required arguments."""
+        required = {a.dest for a in parser._actions if a.required}
+        provided = {a.split("=")[0].lstrip("-") for a in args if a.startswith("-")}
+        return list(required - provided)
+
+    def _get_config_path(self, params: DefaultMunch) -> Optional[str]:
+        """Gets Config path from parameters."""
+        return getattr(params, "config", None)
+
+    def _load_config_file(self, parser: argparse.ArgumentParser, path: str) -> None:
+        """Loads Config from YAML file."""
+        try:
+            with open(os.path.expanduser(path)) as f:
+                config = yaml.safe_load(f)
+                print(f"Loading config from: {path}")
+                parser.set_defaults(**config)
+        except Exception as e:
+            raise InvalidConfigFile(f"Error loading config: {e}") from e
+
+    def _build_config_tree(self, params: DefaultMunch) -> None:
+        """Builds nested Config structure."""
+        for key, value in params.items():
+            if key in ["__is_set"]:
+                continue
+            current = self
+            parts = key.split(".")
+            for part in parts[:-1]:
+                current = current.setdefault(part, Config())
+            current[parts[-1]] = value
+
+    def _detect_set_parameters(
+        self, parser: argparse.ArgumentParser, args: list[str]
+    ) -> None:
+        """Detects which parameters were explicitly set."""
+        temp_parser = self._create_non_default_parser(parser)
+        detected = self._parse_args(args, temp_parser, strict=False)
+        self.__is_set = DefaultMunch(**{k: True for k in detected.keys()})
+
+    def _create_non_default_parser(
+        self, original: argparse.ArgumentParser
+    ) -> argparse.ArgumentParser:
+        """Creates a parser that ignores default values."""
+        parser = deepcopy(original)
+        for action in parser._actions:
+            action.default = argparse.SUPPRESS
+        return parser
+
+    @staticmethod
+    def _parse_args(
+        args: list[str], parser: argparse.ArgumentParser, strict: bool
+    ) -> DefaultMunch:
+        """Parses args with error handling."""
+        try:
+            if strict:
+                result = parser.parse_args(args)
+                return DefaultMunch.fromDict(vars(result))
+
+            result, unknown = parser.parse_known_args(args)
+            for arg in unknown:
+                if arg.startswith("--") and (name := arg[2:]) in vars(result):
+                    setattr(result, name, True)
+            return DefaultMunch.fromDict(vars(result))
+        except Exception:
+            raise ValueError("Invalid arguments provided.")
+
+    def __deepcopy__(self, memo) -> "Config":
+        """Creates a deep copy that maintains Config type."""
+        new_config = Config()
+        memo[id(self)] = new_config
+
+        for key, value in self.items():
+            new_config[key] = deepcopy(value, memo)
+
+        new_config.__is_set = deepcopy(self.__is_set, memo)
+        return new_config
+
+    def merge(self, other: "Config") -> None:
+        """Merges another Config into this one."""
+        self.update(self._merge_dicts(self, other))
+        self.__is_set.update(other.__is_set)
+
+    @staticmethod
+    def _merge_dicts(a: DefaultMunch, b: DefaultMunch) -> DefaultMunch:
+        """Recursively merges two Config objects."""
+        result = deepcopy(a)
+        for key, value in b.items():
+            if key in result:
+                if isinstance(result[key], DefaultMunch) and isinstance(
+                    value, DefaultMunch
+                ):
+                    result[key] = Config._merge_dicts(result[key], value)
+                else:
+                    result[key] = deepcopy(value)
+            else:
+                result[key] = deepcopy(value)
+        return result
+
+    def is_set(self, param_name: str) -> bool:
+        """Checks if a parameter was explicitly set."""
+        return self.__is_set.get(param_name, False)
+
+    def to_dict(self) -> dict:
+        """Returns the configuration as a dictionary."""
+        return self.toDict()
+
+    def _add_default_arguments(self, parser: argparse.ArgumentParser) -> None:
+        """Adds default arguments to the Config parser."""
+        arguments = [
+            (
+                "--config",
+                {
+                    "type": str,
+                    "help": "If set, defaults are overridden by passed file.",
+                    "default": False,
+                },
+            ),
+            (
+                "--strict",
+                {
+                    "action": "store_true",
+                    "help": "If flagged, config will check that only exact arguments have been set.",
+                    "default": False,
+                },
+            ),
+            (
+                "--no_version_checking",
+                {
+                    "action": "store_true",
+                    "help": "Set `true to stop cli version checking.",
+                    "default": False,
+                },
+            ),
+        ]
+
+        for arg_name, kwargs in arguments:
+            try:
+                parser.add_argument(arg_name, **kwargs)
+            except argparse.ArgumentError:
+                # this can fail if argument has already been added.
+                pass
+
+
+T = TypeVar("T", bound="DefaultConfig")
+
+
+class DefaultConfig(Config):
+    """A Config with a set of default values."""
+
+    @classmethod
+    def default(cls: Type[T]) -> T:
+        """Get default config."""
+        raise NotImplementedError("Function default is not implemented.")

{cxppython-0.0.1 → cxppython-0.0.3}/cxppython/main.py

@@ -1,6 +1,7 @@
 def say_hello():
     print("Hello from my_package!")
-
+def say_hello2():
+    print("Hello from my_package!")
 
 if __name__ == '__main__':
     say_hello()

cxppython-0.0.3/cxppython/utils/btlogging/__init__.py

@@ -0,0 +1,11 @@
+"""
+btlogging sub-package standardized logging for Bittensor.
+
+This module provides logging functionality for the Bittensor package. It includes custom loggers, handlers, and
+formatters to ensure consistent logging throughout the project.
+"""
+
+from .loggingmachine import LoggingMachine
+
+
+logging = LoggingMachine(LoggingMachine.config())

cxppython-0.0.3/cxppython/utils/btlogging/console.py

@@ -0,0 +1,73 @@
+"""
+BittensorConsole class gives the ability to log messages to the terminal without changing Bittensor logging level.
+
+Example:
+    from bittensor import logging
+
+    # will be logged
+    logging.console.info("info message")
+    logging.console.error("error message")
+    logging.console.success("success message")
+    logging.console.warning("warning message")
+    logging.console.critical("critical message")
+
+    # will not be logged
+    logging.info("test info")
+"""
+
+from functools import wraps
+from typing import Callable, TYPE_CHECKING
+
+from .helpers import all_loggers
+
+if TYPE_CHECKING:
+    from .loggingmachine import LoggingMachine
+
+
+def _print_wrapper(func: "Callable"):
+    @wraps(func)
+    def wrapper(self: "BittensorConsole", *args, **kwargs):
+        """A wrapper function to temporarily set the logger level to debug."""
+        old_logger_level = self.logger.get_level()
+        self.logger.set_console()
+        func(self, *args, **kwargs)
+
+        for logger in all_loggers():
+            logger.setLevel(old_logger_level)
+
+    return wrapper
+
+
+class BittensorConsole:
+    def __init__(self, logger: "LoggingMachine"):
+        self.logger = logger
+
+    @_print_wrapper
+    def debug(self, message: str):
+        """Logs a DEBUG message to the console."""
+        self.logger.debug(message)
+
+    @_print_wrapper
+    def info(self, message: str):
+        """Logs a INFO message to the console."""
+        self.logger.info(message)
+
+    @_print_wrapper
+    def success(self, message: str):
+        """Logs a SUCCESS message to the console."""
+        self.logger.success(message)
+
+    @_print_wrapper
+    def warning(self, message: str):
+        """Logs a WARNING message to the console."""
+        self.logger.warning(message)
+
+    @_print_wrapper
+    def error(self, message: str):
+        """Logs a ERROR message to the console."""
+        self.logger.error(message)
+
+    @_print_wrapper
+    def critical(self, message: str):
+        """Logs a CRITICAL message to the console."""
+        self.logger.critical(message)

cxppython-0.0.3/cxppython/utils/btlogging/defines.py

@@ -0,0 +1,11 @@
+"""Btlogging constant definition module."""
+
+BASE_LOG_FORMAT = "%(asctime)s | %(levelname)s | %(message)s"
+TRACE_LOG_FORMAT = (
+    f"%(asctime)s | %(levelname)s | %(name)s:%(filename)s:%(lineno)s | %(message)s"
+)
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+BITTENSOR_LOGGER_NAME = "cxppy"
+DEFAULT_LOG_FILE_NAME = "cxppy.log"
+DEFAULT_MAX_ROTATING_LOG_FILE_SIZE = 25 * 1024 * 1024
+DEFAULT_LOG_BACKUP_COUNT = 10

cxppython-0.0.3/cxppython/utils/btlogging/format.py

@@ -0,0 +1,214 @@
+"""
+btlogging.format module
+
+This module defines custom logging formatters for the Bittensor project.
+"""
+
+import logging
+import time
+from typing import Optional
+from colorama import init, Fore, Back, Style
+
+init(wrap=False)
+
+TRACE_LEVEL_NUM: int = 5
+SUCCESS_LEVEL_NUM: int = 21
+
+
+def _trace(self, message: str, *args, **kws):
+    if self.isEnabledFor(TRACE_LEVEL_NUM):
+        self._log(TRACE_LEVEL_NUM, message, args, **kws)
+
+
+def _success(self, message: str, *args, **kws):
+    if self.isEnabledFor(SUCCESS_LEVEL_NUM):
+        self._log(SUCCESS_LEVEL_NUM, message, args, **kws)
+
+
+logging.SUCCESS = SUCCESS_LEVEL_NUM
+logging.addLevelName(SUCCESS_LEVEL_NUM, "SUCCESS")
+logging.Logger.success = _success
+
+logging.TRACE = TRACE_LEVEL_NUM
+logging.addLevelName(TRACE_LEVEL_NUM, "TRACE")
+logging.Logger.trace = _trace
+
+emoji_map: dict[str, str] = {
+    ":white_heavy_check_mark:": "✅",
+    ":cross_mark:": "❌",
+    ":satellite:": "🛰️",
+    ":warning:": "⚠️",
+    ":arrow_right:": "➡️",
+    ":hourglass:": "⏳",
+}
+
+
+color_map: dict[str, str] = {
+    "[red]": Fore.RED,
+    "[/red]": Style.RESET_ALL,
+    "[blue]": Fore.BLUE,
+    "[/blue]": Style.RESET_ALL,
+    "[green]": Fore.GREEN,
+    "[/green]": Style.RESET_ALL,
+    "[magenta]": Fore.MAGENTA,
+    "[/magenta]": Style.RESET_ALL,
+    "[yellow]": Fore.YELLOW,
+    "[/yellow]": Style.RESET_ALL,
+    "[orange]": Fore.YELLOW,
+    "[/orange]": Style.RESET_ALL,
+}
+
+
+log_level_color_prefix: dict[int, str] = {
+    logging.NOTSET: Fore.RESET,
+    logging.TRACE: Fore.MAGENTA,
+    logging.DEBUG: Fore.BLUE,
+    logging.INFO: Fore.WHITE,
+    logging.SUCCESS: Fore.GREEN,
+    logging.WARNING: Fore.YELLOW,
+    logging.ERROR: Fore.RED,
+    logging.CRITICAL: Back.RED,
+}
+
+
+LOG_FORMATS: dict[int, str] = {
+    level: f"{Fore.BLUE}%(asctime)s{Fore.RESET} | {Style.BRIGHT}{color}%(levelname)s\033[0m | %(message)s"
+    for level, color in log_level_color_prefix.items()
+}
+
+LOG_TRACE_FORMATS: dict[int, str] = {
+    level: f"{Fore.BLUE}%(asctime)s{Fore.RESET}"
+    f" | {Style.BRIGHT}{color}%(levelname)s{Fore.RESET}{Back.RESET}{Style.RESET_ALL}"
+    f" | %(name)s:%(filename)s:%(lineno)s"
+    f" | %(message)s"
+    for level, color in log_level_color_prefix.items()
+}
+
+DEFAULT_LOG_FORMAT: str = (
+    f"{Fore.BLUE}%(asctime)s{Fore.RESET} | "
+    f"{Style.BRIGHT}{Fore.WHITE}%(levelname)s{Style.RESET_ALL} | "
+    f"%(name)s:%(filename)s:%(lineno)s | %(message)s"
+)
+
+DEFAULT_TRACE_FORMAT: str = (
+    f"{Fore.BLUE}%(asctime)s{Fore.RESET} | "
+    f"{Style.BRIGHT}{Fore.WHITE}%(levelname)s{Style.RESET_ALL} | "
+    f"%(name)s:%(filename)s:%(lineno)s | %(message)s"
+)
+
+
+class BtStreamFormatter(logging.Formatter):
+    """
+    A custom logging formatter for the Bittensor project that overrides the time formatting to include milliseconds,
+    centers the level name, and applies custom log formats, emojis, and colors.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.trace = False
+
+    def formatTime(self, record, datefmt: Optional[str] = None) -> str:
+        """
+        Override formatTime to add milliseconds.
+
+        Args:
+            record (logging.LogRecord): The log record.
+            datefmt (Optional[str]): The date format string.
+
+        Returns:
+            s (str): The formatted time string with milliseconds.
+        """
+
+        created = self.converter(record.created)
+        if datefmt:
+            s = time.strftime(datefmt, created)
+        else:
+            s = time.strftime("%Y-%m-%d %H:%M:%S", created)
+        s += f".{int(record.msecs):03d}"
+        return s
+
+    def format(self, record: "logging.LogRecord") -> str:
+        """
+        Override format to apply custom formatting including emojis and colors.
+
+        This method saves the original format, applies custom formatting based on the log level and trace flag, replaces
+        text with emojis and colors, and then returns the formatted log record.
+
+        Args:
+            record (logging.LogRecord): The log record.
+
+        Returns:
+            result (str): The formatted log record.
+        """
+
+        format_orig = self._style._fmt
+        record.levelname = f"{record.levelname:^16}"
+
+        if record.levelno not in LOG_FORMATS:
+            self._style._fmt = (
+                DEFAULT_TRACE_FORMAT if self.trace else DEFAULT_LOG_FORMAT
+            )
+        else:
+            if self.trace is True:
+                self._style._fmt = LOG_TRACE_FORMATS[record.levelno]
+            else:
+                self._style._fmt = LOG_FORMATS[record.levelno]
+
+        for text, emoji in emoji_map.items():
+            record.msg = record.msg.replace(text, emoji)
+        # Apply color specifiers
+        for text, color in color_map.items():
+            record.msg = record.msg.replace(text, color)
+
+        result = super().format(record)
+        self._style._fmt = format_orig
+
+        return result
+
+    def set_trace(self, state: bool = True):
+        """Change formatter state."""
+        self.trace = state
+
+
+class BtFileFormatter(logging.Formatter):
+    """
+    BtFileFormatter
+
+    A custom logging formatter for the Bittensor project that overrides the time formatting to include milliseconds and
+    centers the level name.
+    """
+
+    def formatTime(
+        self, record: "logging.LogRecord", datefmt: Optional[str] = None
+    ) -> str:
+        """
+        Override formatTime to add milliseconds.
+
+        Args:
+            record (logging.LogRecord): The log record.
+            datefmt (Optional[str]): The date format string.
+
+        Returns:
+            s (str): The formatted time string with milliseconds.
+        """
+
+        created = self.converter(record.created)
+        if datefmt:
+            s = time.strftime(datefmt, created)
+        else:
+            s = time.strftime("%Y-%m-%d %H:%M:%S", created)
+        s += f".{int(record.msecs):03d}"
+        return s
+
+    def format(self, record: "logging.LogRecord") -> str:
+        """
+        Override format to center the level name.
+
+        Args:
+            record (logging.LogRecord): The log record.
+
+        Returns:
+            formatted record (str): The formatted log record.
+        """
+        record.levelname = f"{record.levelname:^10}"
+        return super().format(record)

cxppython-0.0.3/cxppython/utils/btlogging/helpers.py

@@ -0,0 +1,71 @@
+"""
+btlogging.helpers module provides helper functions for the Bittensor logging system.
+"""
+
+import logging
+from typing import Generator
+
+
+def all_loggers() -> Generator["logging.Logger", None, None]:
+    """Generator that yields all logger instances in the application.
+
+    Iterates through the logging root manager's logger dictionary and yields all active `Logger` instances. It skips
+    placeholders and other types that are not instances of `Logger`.
+
+    Yields:
+        logger (logging.Logger): An active logger instance.
+    """
+    for logger in logging.root.manager.loggerDict.values():
+        if isinstance(logger, logging.PlaceHolder):
+            continue
+        # In some versions of Python, the values in loggerDict might be
+        # LoggerAdapter instances instead of Logger instances.
+        # We check for Logger instances specifically.
+        if isinstance(logger, logging.Logger):
+            yield logger
+        else:
+            # If it's not a Logger instance, it could be a LoggerAdapter or
+            # another form that doesn't directly offer logging methods.
+            # This branch can be extended to handle such cases as needed.
+            pass
+
+
+def all_logger_names() -> Generator[str, None, None]:
+    """
+    Generate the names of all active loggers.
+
+    This function iterates through the logging root manager's logger dictionary and yields the names of all active
+    `Logger` instances. It skips placeholders and other types that are not instances of `Logger`.
+
+    Yields:
+        name (str): The name of an active logger.
+    """
+    for name, logger in logging.root.manager.loggerDict.items():
+        if isinstance(logger, logging.PlaceHolder):
+            continue
+        # In some versions of Python, the values in loggerDict might be
+        # LoggerAdapter instances instead of Logger instances.
+        # We check for Logger instances specifically.
+        if isinstance(logger, logging.Logger):
+            yield name
+        else:
+            # If it's not a Logger instance, it could be a LoggerAdapter or
+            # another form that doesn't directly offer logging methods.
+            # This branch can be extended to handle such cases as needed.
+            pass
+
+
+def get_max_logger_name_length() -> int:
+    """
+    Calculate and return the length of the longest logger name.
+
+    This function iterates through all active logger names and determines the length of the longest name.
+
+    Returns:
+        max_length (int): The length of the longest logger name.
+    """
+    max_length = 0
+    for name in all_logger_names():
+        if len(name) > max_length:
+            max_length = len(name)
+    return max_length