pkg-40400 0.1.0__py3-none-any.whl

pkg_40400/__init__.py

@@ -0,0 +1,15 @@
+from pkg_40400.core.config import ClsSettings
+from pkg_40400.core.decorator import ClsFalseError, raise_on_false
+from pkg_40400.core.logger import get_logger, initialize_logger
+
+__version__ = "0.1.0"
+version = __version__
+
+__all__ = (
+    "ClsSettings",
+    "ClsFalseError",
+    "get_logger",
+    "initialize_logger",
+    "raise_on_false",
+    "version",
+)

pkg_40400/cli.py

@@ -0,0 +1,25 @@
+"""
+Calculator CLI - pkg-40400
+
+A command-line interface for basic arithmetic operations using click.
+"""
+
+import sys
+
+from pkg_40400 import get_logger, initialize_logger, version
+
+
+def main():
+    """Main entry point for the CLI."""
+    initialize_logger()
+    logger = get_logger()
+    try:
+        logger.info(version)
+    except Exception as e:
+        logger = get_logger()
+        logger.error(str(e))
+        sys.exit(1)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

pkg_40400/core/config.py

@@ -0,0 +1,93 @@
+import os
+import pathlib
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ClsSettings:
+    """
+    Centralized configuration settings.
+
+    This dataclass reads environment variables on instantiation and computes
+    derived values. It is designed to be instantiated once at application
+    startup and passed to components that need configuration.
+
+    Note: This dataclass is immutable (frozen). All fields are set during
+    initialization and cannot be modified afterward.
+    """
+
+    # Environment-dependent configuration
+    ENV: str
+    DEBUG: bool
+    LOGGERS_NAME: str
+
+    # Logging file configuration (read from environment)
+    LOG_CFG_FILE: str = "logging.yaml"
+    LOG_DST_FILE: str = "app.log"
+
+    # File paths (computed from environment variables)
+    PROJECT_ROOT: pathlib.Path = None  # type: ignore
+    LOG_CFG_PATH: pathlib.Path = None  # type: ignore
+    LOG_LEVEL: int = None  # type: ignore
+
+    def __init__(
+        self,
+        env: str | None = None,
+        debug: bool | None = None,
+        loggers_name: str | None = None,
+    ) -> None:
+        """
+        Initialize configuration from environment variables.
+
+        Args:
+            env: Override ENV value. If None, reads from ENV env var.
+            debug: Override DEBUG value. If None, reads from DEBUG env var.
+            loggers_name: Override LOGGERS_NAME value. If None, reads from LOGGERS_NAME env var.
+        """
+        # Set defaults at initialization time
+        object.__setattr__(self, "ENV", self._validate_env(env))
+        object.__setattr__(self, "DEBUG", self._validate_debug(debug))
+        object.__setattr__(self, "LOGGERS_NAME", self._validate_loggers_name(loggers_name))
+        object.__setattr__(self, "LOG_CFG_FILE", os.getenv("LOG_CFG_FILE", "logging.yaml"))
+        object.__setattr__(self, "LOG_DST_FILE", os.getenv("LOG_DST_FILE", "app.log"))
+
+        # Compute derived values once
+        object.__setattr__(self, "PROJECT_ROOT", self._compute_project_root())
+        object.__setattr__(self, "LOG_CFG_PATH", self._compute_log_cfg_path())
+        object.__setattr__(self, "LOG_LEVEL", self._compute_log_level())
+
+    def _validate_env(self, env: str | None = None) -> str:
+        """Validate and normalize ENV value."""
+        value = env if env is not None else os.getenv("ENV", "development")
+        value = value.lower()
+        valid_values = ("development", "production", "local")
+        return value if value in valid_values else "development"
+
+    def _validate_debug(self, debug: bool | None = None) -> bool:
+        """Validate and normalize DEBUG value."""
+        if debug is not None:
+            return bool(debug)
+
+        debug_str = os.getenv("DEBUG", "true")
+        return debug_str.lower() in ("true", "1", "t", "yes")
+
+    def _validate_loggers_name(self, loggers_name: str | None = None) -> str:
+        """Validate and normalize LOGGERS_NAME value."""
+        value = loggers_name if loggers_name is not None else os.getenv("LOGGERS_NAME", "default")
+        value = value.lower()
+        valid_values = ("default", "docker", "local", "lambda", "library")
+        return value if value in valid_values else "default"
+
+    def _compute_project_root(self) -> pathlib.Path:
+        """Compute the project root directory."""
+        # The config module is at src/pkg_40400/core/config.py
+        # So we need to go up 3 levels to get to src/, then up 1 more to get to project root
+        return pathlib.Path(__file__).parent.parent.parent.parent
+
+    def _compute_log_cfg_path(self) -> pathlib.Path:
+        """Compute the path to the logging configuration file."""
+        return self.PROJECT_ROOT / "config" / self.LOG_CFG_FILE
+
+    def _compute_log_level(self) -> int:
+        """Compute the log level based on DEBUG setting."""
+        return 10 if self.DEBUG else 20  # 10: DEBUG, 20: INFO

pkg_40400/core/decorator.py

@@ -0,0 +1,77 @@
+from functools import wraps
+from typing import Callable, Optional, TypeVar
+
+from pkg_40400.core.logger import get_logger
+
+F = TypeVar("F", bound=Callable[..., bool])
+
+
+class ClsFalseError(ValueError):
+    """Exception raised when a function decorated with @raise_on_false returns False."""
+
+    def __init__(self, func_name: str, custom_message: Optional[str] = None) -> None:
+        """
+        Initialize the exception.
+
+        Args:
+            func_name: Name of the function that returned False.
+            custom_message: Optional custom message to include in the error.
+        """
+        self.func_name = func_name
+        self.custom_message = custom_message
+
+        if custom_message is not None:
+            message = f"{func_name} returned '{custom_message}'"
+        else:
+            message = f"{func_name} returned 'False'"
+        super().__init__(message)
+
+
+def raise_on_false(
+    exception_type: type[ValueError] = ClsFalseError,
+    custom_message: Optional[str] = None,
+    log_error: bool = True,
+):
+    """
+    Decorator that raises an exception if the decorated function returns False.
+
+    Args:
+        exception_type: The exception type to raise. Must be a subclass of ValueError.
+        custom_message: Optional custom message to include in the exception.
+        log_error: If True, log the error using the configured logger before raising.
+
+    Returns:
+        A decorator function.
+
+    Usage:
+        @raise_on_false()
+        def validate_input(data: dict) -> bool:
+            return "required_key" in data
+
+        @raise_on_false(custom_message="Data validation failed", log_error=False)
+        def process_data(data: dict) -> bool:
+            return validate_required_fields(data)
+    """
+    if not issubclass(exception_type, ValueError):
+        raise TypeError(f"exception_type must be a subclass of ValueError, got {exception_type}")
+
+    def decorator(func: F) -> F:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            result = func(*args, **kwargs)
+
+            if not result:
+                exception = exception_type(func.__name__, custom_message)
+
+                if log_error:
+                    logger = get_logger()
+                    # Use stacklevel=2 to point to the caller (wrapper's caller), not the decorator
+                    logger.error(str(exception), stacklevel=2)
+
+                raise exception
+
+            return result
+
+        return wrapper  # type: ignore[return-value]
+
+    return decorator

pkg_40400/core/logger.py

@@ -0,0 +1,84 @@
+"""Logging module with YAML configuration support."""
+
+import logging
+from logging import config
+
+import yaml
+
+from pkg_40400.core.config import ClsSettings
+
+# Placeholder logger - will be replaced on first initialization
+
+Logger: logging.Logger = logging.getLogger("default")
+_initialized: bool = False
+
+
+def initialize_logger() -> logging.Logger:
+    """Initialize the package logger with YAML configuration.
+
+    This function configures logging using the YAML file specified in
+    config/constants.yaml or environment variables. It should only be called
+    once during application startup.
+
+    Returns:
+        The configured Logger instance.
+
+    Notes:
+        - Environment variables can override logging settings
+        - Falls back to basicConfig if YAML file cannot be loaded
+    """
+    global Logger, _initialized
+
+    if _initialized:
+        # On subsequent calls, update the level if needed
+        settings = ClsSettings()
+        Logger.setLevel(settings.LOG_LEVEL)
+        return Logger
+
+    settings = ClsSettings()
+    log_level = settings.LOG_LEVEL
+    log_config_path = settings.LOG_CFG_PATH
+    logger_name = settings.LOGGERS_NAME
+
+    Logger = logging.getLogger(logger_name)
+
+    # If the logger already has handlers attached, assume configuration has
+    # already been performed and skip reconfiguration.
+    if Logger.handlers:
+        Logger.setLevel(log_level)
+        _initialized = True
+        return Logger
+
+    try:
+        with open(log_config_path, "r") as f:
+            config_dict = yaml.safe_load(f)
+        config.dictConfig(config_dict)
+    except Exception as e:
+        LOG_FORMAT = "%(asctime)s.%(msecs)03d::%(levelname)s::%(funcName)s::%(filename)s:%(lineno)s::%(message)s"
+        logging.basicConfig(level=log_level, format=LOG_FORMAT)
+        Logger.warning(e)
+
+    Logger.setLevel(log_level)
+    _initialized = True
+    return Logger
+
+
+def get_logger(name: str | None = None) -> logging.Logger:
+    """Get a logger instance by name.
+
+    This function provides flexibility to get named loggers throughout the
+    application without reinitializing the logging system.
+
+    Args:
+        name: The name of the logger to retrieve. If None, uses the configured
+            logger name from the global Logger. Defaults to None.
+
+    Returns:
+        A Logger instance with the specified name.
+    """
+    if name is None:
+        return Logger
+    return logging.getLogger(name)
+
+
+setup_logging = initialize_logger

pkg_40400-0.1.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.5
+Name: pkg-40400
+Version: 0.1.0
+Project-URL: Changelog, https://github.com/tagdots-dev/bobo-test/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/tagdots-dev/bobo-test/blob/main/README.md
+Project-URL: Homepage, https://github.com/tagdots-dev
+Project-URL: Issues, https://github.com/tagdots-dev/bobo-test/issues
+Project-URL: Repository, https://github.com/tagdots-dev/bobo-test
+Author-email: developers <developers@tagdots.com>
+License-File: LICENSE
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.12.10
+Requires-Dist: pyyaml~=6.0.3
+Description-Content-Type: text/markdown
+
+# bobo-test
+
+repo test

pkg_40400-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pkg_40400/__init__.py,sha256=wDvtIjXO5TdNBav5ry-bNIB7HY0C_idNJZhS7Yl7PWY,357
+pkg_40400/cli.py,sha256=I6z4ccZNjbCdJOwAeivIqgesiL9X5bdBB3zVT9Dk2mI,488
+pkg_40400/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pkg_40400/core/config.py,sha256=mufT5KGeWiaCWQKTpYpqoyxZeHl_KoezAcd7XWTaHqs,3861
+pkg_40400/core/decorator.py,sha256=SijhkVAlL-7nDLR4K0WbHfs-vH9s94XwL9xhRC3Invk,2495
+pkg_40400/core/logger.py,sha256=bfgXOor_mCxJm-EggkHWwHQJb-mDQlCHtcerzHmep8Y,2465
+pkg_40400/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pkg_40400/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pkg_40400/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pkg_40400-0.1.0.dist-info/METADATA,sha256=aCV8cLMFB8FRduDaG5Pn2cdbEjuIENSv4MSt9dhC1L4,921
+pkg_40400-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+pkg_40400-0.1.0.dist-info/entry_points.txt,sha256=ptbWAIgF7fAkDySVI8N8JmfkY_cmFrkvjUGer1KTN0Q,49
+pkg_40400-0.1.0.dist-info/licenses/LICENSE,sha256=wAf7nWZg78po80uuZfneGnerTtGFxdVSv8uFSMfj2iA,1070
+pkg_40400-0.1.0.dist-info/RECORD,,

pkg_40400-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pkg_40400-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pkg-40400 = pkg_40400.cli:main

pkg_40400-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 TagDots, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+and associated documentation files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.