click_logging_config 2.0.2__py3-none-any.whl

click_logging_config/VERSION

@@ -0,0 +1 @@
+2.0.2

click_logging_config/__init__.py

@@ -0,0 +1,5 @@
+#  Copyright (c) 2022 Russell Smiley
+#
+#  This file is part of click_logging_config.
+
+"""Quick and easy logging parameters for click commands."""

click_logging_config/_click.py

@@ -0,0 +1,143 @@
+#
+#  Copyright (c) 2022 Russell Smiley
+#
+#  This file is part of click_logging_config.
+#
+#  You should have received a copy of the MIT License along with build_harness.
+#  If not, see <https://opensource.org/licenses/MIT>.
+#
+
+import copy
+import functools
+import logging
+import pathlib
+import typing
+
+import click
+from click.decorators import FC
+
+from ._default_values import VALID_LOG_LEVELS
+from ._logging import LoggingConfiguration, LoggingState
+from ._version import __version__
+
+log = logging.getLogger(__name__)
+
+LOG_STATE_KEY = "logging_state"
+
+
+def logging_parameters(
+    default_configuration: typing.Optional[LoggingConfiguration] = None,
+) -> typing.Union[typing.Callable[..., typing.Any], click.Command]:
+    """Define a set of logging configuration options to a ``click`` command.
+
+    Args:
+        default_configuration: User defined logging default configuration.
+
+    Returns:
+        The decorator function object.
+    """
+    resolved_configuration: LoggingConfiguration
+    if not default_configuration:
+        resolved_configuration = LoggingConfiguration()
+    else:
+        resolved_configuration = typing.cast(
+            LoggingConfiguration, default_configuration
+        )
+
+    def decorator(f: FC) -> FC:
+        @click.option(
+            "--log-console-enable/--log-console-disable",
+            "enable_console_log",
+            default=resolved_configuration.enable_console_logging,
+            help="Enable or disable console logging.",
+            is_flag=True,
+            show_default=True,
+        )
+        @click.option(
+            "--log-console-json-enable/--log-console-json-disable",
+            "enable_console_json",
+            default=resolved_configuration.console_logging.json_enabled,
+            help="Enable or disable console JSON logging.",
+            is_flag=True,
+            show_default=True,
+        )
+        @click.option(
+            "--log-file-enable/--log-file-disable",
+            "enable_file_log",
+            default=resolved_configuration.enable_file_logging,
+            help="Enable or disable file logging.",
+            is_flag=True,
+            show_default=True,
+        )
+        @click.option(
+            "--log-file-json-enable/--log-file-json-disable",
+            "enable_file_json",
+            default=resolved_configuration.file_logging.json_enabled,
+            help="Enable or disable file JSON logging.",
+            is_flag=True,
+            show_default=True,
+        )
+        @click.option(
+            "--log-file",
+            "log_file",
+            default=resolved_configuration.file_logging.log_file_path,
+            help="The log file to write to.",
+            is_eager=True,
+            show_default=True,
+            type=click.Path(
+                dir_okay=False,
+                exists=False,
+                file_okay=True,
+                path_type=pathlib.Path,
+                writable=True,
+                readable=True,
+            ),
+        )
+        @click.option(
+            "--log-level",
+            "log_level",
+            default=resolved_configuration.log_level,
+            help="Select logging level to apply to all enabled log sinks.",
+            show_default=True,
+            type=click.Choice(VALID_LOG_LEVELS, case_sensitive=False),
+        )
+        def wrapper(
+            *args: typing.Any,
+            enable_console_log: bool,
+            enable_console_json: bool,
+            enable_file_log: bool,
+            enable_file_json: bool,
+            log_file: pathlib.Path,
+            log_level: str,
+            **kwargs: typing.Any,
+        ) -> typing.Any:
+            ctx = click.get_current_context()
+            this_object = ctx.ensure_object(dict)
+            if LOG_STATE_KEY not in this_object:
+                this_configuration = copy.deepcopy(resolved_configuration)
+                this_configuration.enable_console_logging = enable_console_log
+                this_configuration.console_logging.json_enabled = (
+                    enable_console_json
+                )
+                this_configuration.enable_file_logging = enable_file_log
+                this_configuration.file_logging.json_enabled = enable_file_json
+                this_configuration.file_logging.log_file_path = log_file
+                this_configuration.log_level = log_level
+
+                this_object[LOG_STATE_KEY] = LoggingState(this_configuration)
+                log.info(f"Click logging config version, {__version__}")
+            elif not isinstance(this_object, dict):
+                raise RuntimeError(
+                    "Unable to define logging state since click context.obj is "
+                    "not a dictionary"
+                )
+
+            return ctx.invoke(
+                f,
+                *args,
+                **kwargs,
+            )
+
+        return typing.cast(FC, functools.update_wrapper(wrapper, f))
+
+    return decorator

click_logging_config/_default_values.py

@@ -0,0 +1,26 @@
+#  Copyright (c) 2020 Russell Smiley
+#
+#  This file is part of click_logging_config.
+#
+#  You should have received a copy of the MIT License along with build_harness.
+#  If not, see <https://opensource.org/licenses/MIT>.
+
+"""Default values."""
+
+import pathlib
+
+DEFAULT_RELEASE_ID = "0.0.0"
+
+DEFAULT_CONSOLE_JSON_ENABLED = False
+DEFAULT_CONSOLE_LOGGING_ENABLED = False
+
+DEFAULT_FILE_JSON_ENABLED = True
+DEFAULT_FILE_LOGGING_ENABLED = True
+DEFAULT_FILE_ROTATION_BACKUPS = 10
+DEFAULT_FILE_ROTATION_SIZE_MB = 1
+
+DEFAULT_LOG_FILE = pathlib.Path("this.log")
+DEFAULT_LOG_FORMAT = "%(asctime)s::%(levelname)s::%(name)s::%(message)s"
+DEFAULT_LOG_LEVEL = "warning"
+
+VALID_LOG_LEVELS = ["critical", "error", "warning", "info", "debug", "notset"]

click_logging_config/_logging.py

@@ -0,0 +1,207 @@
+#  Copyright (c) 2022 Russell Smiley
+#
+#  This file is part of click_logging_config.
+#
+#  You should have received a copy of the MIT License along with build_harness.
+#  If not, see <https://opensource.org/licenses/MIT>.
+
+"""Logging configuration and state."""
+
+import logging.handlers
+import pathlib
+import typing
+
+import json_log_formatter  # type: ignore
+import pendulum
+import pydantic
+import pytz
+
+from ._default_values import (
+    DEFAULT_CONSOLE_JSON_ENABLED,
+    DEFAULT_CONSOLE_LOGGING_ENABLED,
+    DEFAULT_FILE_JSON_ENABLED,
+    DEFAULT_FILE_LOGGING_ENABLED,
+    DEFAULT_FILE_ROTATION_BACKUPS,
+    DEFAULT_FILE_ROTATION_SIZE_MB,
+    DEFAULT_LOG_FILE,
+    DEFAULT_LOG_FORMAT,
+    DEFAULT_LOG_LEVEL,
+)
+
+
+class ConsoleLogging(pydantic.BaseModel):
+    """Console log configuration parameters."""
+
+    json_enabled: bool = DEFAULT_CONSOLE_JSON_ENABLED
+
+
+class FileLogging(pydantic.BaseModel):
+    """Log file configuration parameters.
+
+    In this context file logs are *always* rotated - the rotation just might be
+    at a relatively large file size. As a best practice, not rotating log files
+    is considered not particularly useful.
+    """
+
+    json_enabled: bool = DEFAULT_FILE_JSON_ENABLED
+    log_file_path: pathlib.Path = DEFAULT_LOG_FILE
+    file_rotation_size_megabytes: int = DEFAULT_FILE_ROTATION_SIZE_MB
+    max_rotation_backup_files: int = DEFAULT_FILE_ROTATION_BACKUPS
+
+
+class LoggingConfiguration(pydantic.BaseModel):
+    """Logging configuration data."""
+
+    log_level: str = DEFAULT_LOG_LEVEL
+
+    enable_console_logging: bool = DEFAULT_CONSOLE_LOGGING_ENABLED
+    console_logging: ConsoleLogging = ConsoleLogging()
+
+    enable_file_logging: bool = DEFAULT_FILE_LOGGING_ENABLED
+    file_logging: FileLogging = FileLogging()
+
+
+U = typing.TypeVar("U", bound="Iso8601Formatter")
+
+
+class Iso8601Formatter(logging.Formatter):
+    """Custom formatter with ISO-8601 timestamps."""
+
+    converter: typing.Callable[..., pendulum.DateTime] = pendulum.from_timestamp  # type: ignore [assignment]
+
+    def formatTime(
+        self: U,
+        record: logging.LogRecord,
+        datefmt: typing.Optional[str] = None,
+        timezone: typing.Optional[str] = None,
+    ) -> str:
+        """Generate formatted time."""
+        if timezone:
+            v = Iso8601Formatter.converter(
+                record.created,
+                tz=pytz.timezone(timezone),
+            ).isoformat()
+        else:
+            v = Iso8601Formatter.converter(
+                record.created,
+            ).isoformat()
+
+        return v
+
+
+T = typing.TypeVar("T", bound="LoggingState")
+
+
+class LoggingState:
+    """Logging configuration parameters."""
+
+    configuration: LoggingConfiguration
+    _console_handler: typing.Optional[logging.StreamHandler]
+    _rotation_handler: typing.Optional[logging.handlers.RotatingFileHandler]
+
+    def __init__(
+        self: T,
+        logging_configuration: LoggingConfiguration,
+    ) -> None:
+        """Construct ``LoggingState`` object.
+
+        Args:
+            logging_configuration: Logging configuration to be applied.
+        """
+        self.configuration = logging_configuration
+        self._console_handler = None
+        self._rotation_handler = None
+
+        self.set_logging_state()
+
+    def set_logging_state(self: T) -> None:
+        """Apply the logging state from configuration."""
+        root_logger = logging.getLogger()
+        self.__set_log_level(root_logger)
+        self.__set_file_logging(root_logger)
+        self.__set_console_logging(root_logger)
+
+    def __level_value(self: T) -> int:
+        """Convert log level text to a ``logging`` framework integer."""
+        return getattr(logging, self.configuration.log_level.upper())
+
+    def __set_file_logging(self: T, root_logger: logging.Logger) -> None:
+        """Enable or disable file logging.
+
+        Args:
+            root_logger: Root logger to modify.
+        """
+        if self.configuration.enable_file_logging:
+            # No change if a rotation handler already exists.
+            if not self._rotation_handler:
+                this_handler = logging.handlers.RotatingFileHandler(
+                    str(self.configuration.file_logging.log_file_path),
+                    backupCount=(
+                        self.configuration.file_logging.max_rotation_backup_files  # noqa: E501
+                    ),
+                    maxBytes=(  # noqa: E501
+                        self.configuration.file_logging.file_rotation_size_megabytes  # noqa: E501
+                        * (1024**2)
+                    ),
+                )
+                this_handler.setLevel(self.__level_value())
+                if self.configuration.file_logging.json_enabled:
+                    this_handler.setFormatter(
+                        json_log_formatter.VerboseJSONFormatter()
+                    )
+                else:
+                    this_handler.setFormatter(
+                        Iso8601Formatter(fmt=DEFAULT_LOG_FORMAT)
+                    )
+
+                self._rotation_handler = this_handler
+
+                root_logger.addHandler(self._rotation_handler)
+        elif self._rotation_handler:
+            self._rotation_handler.flush()
+            self._rotation_handler.close()
+            root_logger.removeHandler(self._rotation_handler)
+            self._rotation_handler = None
+        # else self._rotation_handler is None and not self.enable_file_logging
+        # so do nothing
+
+    def __set_console_logging(self: T, root_logger: logging.Logger) -> None:
+        """Enable or disable console logging.
+
+        Args:
+            root_logger: Root logger to modify.
+        """
+        if self.configuration.enable_console_logging:
+            # No change if a console handler already exists.
+            if not self._console_handler:
+                self._console_handler = logging.StreamHandler()
+                self._console_handler.setLevel(self.__level_value())
+                if self.configuration.console_logging.json_enabled:
+                    self._console_handler.setFormatter(
+                        json_log_formatter.VerboseJSONFormatter()
+                    )
+                else:
+                    self._console_handler.setFormatter(
+                        Iso8601Formatter(fmt=DEFAULT_LOG_FORMAT)
+                    )
+
+                root_logger.addHandler(self._console_handler)
+        elif self._console_handler:
+            self._console_handler.flush()
+            self._console_handler.close()
+            root_logger.removeHandler(self._console_handler)
+            self._console_handler = None
+        # else self._console_handler is None and not
+        # self.enable_console_logging so do nothing
+
+    def __set_log_level(self: T, root_logger: logging.Logger) -> None:
+        """Set log level on any existing handlers.
+
+        Args:
+            root_logger: Root logger to modify.
+        """
+        for this_handler in root_logger.handlers:
+            this_handler.setLevel(self.__level_value())
+        # Ensure that the logging level propagates to any subsequently created
+        # handlers by setting the root logger level as well.
+        root_logger.setLevel(self.__level_value())

click_logging_config/_version.py

@@ -0,0 +1,38 @@
+#  Copyright (c) 2020 Russell Smiley
+#
+#  This file is part of build_harness.
+#
+#  You should have received a copy of the MIT License along with build_harness.
+#  If not, see <https://opensource.org/licenses/MIT>.
+
+"""Package version management."""
+
+import pathlib
+
+from click_logging_config._default_values import DEFAULT_RELEASE_ID
+
+
+def acquire_version() -> str:
+    """Acquire PEP-440 compliant version from VERSION file.
+
+    Returns:
+        Acquired version text.
+    Raises:
+        RuntimeError: If version is not valid.
+    """
+    here = pathlib.Path(__file__).parent
+    version_file_path = (here / "VERSION").absolute()
+
+    if version_file_path.is_file():
+        with version_file_path.open(mode="r") as version_file:
+            version = version_file.read().strip()
+    else:
+        version = DEFAULT_RELEASE_ID
+
+    if not version:
+        raise RuntimeError("Unable to acquire version")
+
+    return version
+
+
+__version__ = acquire_version()

click_logging_config/parameters.py

@@ -0,0 +1,13 @@
+#  Copyright (c) 2024 Russell Smiley
+#
+#  This file is part of click_logging_config.
+#
+#  You should have received a copy of the MIT License along with
+#  click_logging_config.
+#  If not, see <https://opensource.org/licenses/MIT>.
+#
+
+"""Convenience imports of core functionality."""
+
+from ._click import logging_parameters  # noqa: F401
+from ._logging import LoggingConfiguration, LoggingState  # noqa: F401

click_logging_config-2.0.2.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: click_logging_config
+Version: 2.0.2
+Dynamic: Summary
+Project-URL: source, https://gitlab.com/ci-cd-devops/click_logging_config
+Author-email: Russell Smiley <russell@bytingchipmunk.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: click>=8.3
+Requires-Dist: json-log-formatter>=1.0
+Requires-Dist: pendulum>=3.1
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: pytz>=2025.2
+Provides-Extra: dev
+Requires-Dist: invoke>=2.2.0; extra == 'dev'
+Requires-Dist: mypy>=1.18.2; extra == 'dev'
+Requires-Dist: pre-commit>=4.3; extra == 'dev'
+Requires-Dist: ruff>=0.14.4; extra == 'dev'
+Requires-Dist: types-pytz>=2025.2; extra == 'dev'
+Requires-Dist: uv>=0.9.8; extra == 'dev'
+Provides-Extra: doc
+Requires-Dist: sphinx-rtd-theme>=2.0; extra == 'doc'
+Requires-Dist: sphinx>=7.4.7; extra == 'doc'
+Provides-Extra: test
+Requires-Dist: pytest-cov>=7.0; extra == 'test'
+Requires-Dist: pytest-mock>=3.15.1; extra == 'test'
+Requires-Dist: pytest>=8.4.2; extra == 'test'
+Description-Content-Type: text/x-rst
+
+click-logging-config
+====================
+
+Quick and easy CLI logging options for `click <https://palletsprojects.com/p/click/>`_
+commands using a Python decorator.
+
+I found myself implementing logging preferences repeatedly for utilities. Logging
+configuration is pretty simple, but for each new implementation I would
+find myself spending time researching the same options to refresh my memory and
+then implementing something slightly different than the last time. 🙄
+
+``click-logging-config`` is my attempt to stop the circle of re-implementation
+with settings that are useful enough, with configurability to change it if you
+don't like the out-of-box behaviour. It's proving to be pretty useful and I'm
+already using it across several of my other projects. 😄
+
+It is released under the MIT license so you are free to use it in lots of
+different ways. As simple as it looks, a tool like this still represents
+research time and implementation effort, so please use the link below to help
+support development.
+
+`Support click-logging-config <https://byting-chipmunk.ck.page/products/click-logging-config>`_
+
+`Byting Chipmunk <https://bytingchipmunk.com>`_ 🐿
+
+*Take a byte off.*
+
+
+.. contents::
+
+.. section-numbering::
+
+
+Installation
+------------
+
+The ``click-logging-config`` package is available from PyPI. Installing
+into a virtual environment is recommended.
+
+.. code-block::
+
+    python3 -m venv .venv; .venv/bin/pip install click-logging-config
+
+
+Getting Started
+---------------
+
+Using ``click-logging-config`` is intended to be very simple. A single
+decorator applied to your click command or group adds some click options
+specifically for managing logging context.
+
+.. code-block::
+
+    import click
+    import logging
+    from click_logging import logging_parameters
+
+    log = logging.getLogger(__name__)
+
+    def do_something()
+        pass
+
+    @click.command()
+    @click.option("--my-option", type=str)
+    # NOTE: Empty braces are required for hard-coded click-logging-config defaults.
+    @logging_parameters()
+    def my_command(my_option: str) -> None:
+        log.info("doing something")
+        try:
+            do_something(my_option)
+        except Exception as e:
+            log.critical(f"something bad happened, {str(e)}")
+            raise
+
+
+Application of the ``@logging_parameters`` decorator must be applied immediately
+*above* your click command function and *below* any other click decorators such
+as arguments and options.
+
+Having applied the decorator, your command now has the following options
+available to it.
+
+.. code-block::
+
+    --log-console-enable / --log-console-disable
+                           Enable or disable console logging.
+                           [default: log-console-disable]
+    --log-console-json-enable / --log-console-json-disable
+                           Enable or disable console JSON logging.
+                           [default: log-console-json-disable]
+    --log-file-enable / --log-file-disable
+                           Enable or disable file logging.
+                           [default: log-file-enable]
+    --log-file-json-enable / --log-file-json-disable
+                           Enable or disable file JSON logging.
+                           [default: log-file-json-enable]
+    --log-file FILE        The log file to write to.  [default: this.log]
+    --log-level [critical|error|warning|info|debug|notset]
+                           Select logging level to apply to all enabled
+                           log sinks.  [default: warning]
+
+Note that the single log level configuration parameter applies to both console
+and file logging.
+
+The internal defaults are configured for an interactive utility (run by a
+human in a terminal rather than via automation, or in a container). In summary,
+
+* disabled console logging (allows your application to use console output, if needed)
+* enabled file logging (1MB rotation size, with 10 rotation backups)
+* "warning" log level
+
+
+Custom defaults
+---------------
+
+If you don't like the ``click-logging-config`` internal defaults for the options
+you can define your own. The ``LoggingConfiguration`` class is derived from
+``pydantic.BaseModel``, so one easy way to define your defaults is using a
+dictionary. You only need to define values you want to change - any other value
+will continue using the internal defaults.
+
+.. code-block::
+
+    import pathlib
+
+    import click
+    import logging
+    from click_logging import logging_parameters, LoggingConfiguration
+
+    log = logging.getLogger(__name__)
+
+    MY_LOGGING_DEFAULTS = LoggingConfiguration.parse_obj(
+        {
+            "file_logging": {
+                # NOTE: file path must be specified using pathlib.Path
+                "log_file_path": pathlib.Path("some_other.log"),
+            },
+            "log_level": "info",
+        }
+    )
+
+    def do_something()
+        pass
+
+    @click.command()
+    @click.option("--my-option", type=str)
+    @logging_parameters(MY_LOGGING_DEFAULTS)
+    def my_command(my_option: str) -> None:
+        log.info("doing something")
+        try:
+            do_something(my_option)
+        except Exception as e:
+            log.critical(f"something bad happened, {str(e)}")
+            raise
+
+
+The table below summarizes the available settings for defaults. Otherwise
+review the ``LoggingConfiguration`` `class definition <https://gitlab.com/ci-cd-devops/click_logging_config/-/blob/main/click_logging_config/_logging.py#L52>`_ .
+
+.. csv-table:: Available top-level settings for logging defaults.
+   :header: "Setting", "Type", "Hard default", "Description"
+
+    "log_level", "str", "warning", "Define log level"
+    "enable_console_logging", "boolean", "False", "Enable console logging"
+    "console_logging", "dict", "", "Console logging specific settings. See table below."
+    "enable_file_logging", "bool", "True", "Enable file logging"
+    "file_logging", "dict", "", "File logging specific settings. See table below."
+
+.. csv-table:: Available console logging defaults.
+   :header: "Setting", "Type", "Hard default", "Description"
+
+    "json_enabled", "bool", "False", "Output JSON logs using ``json_log_formatter``"
+
+.. csv-table:: Available file logging defaults.
+   :header: "Setting", "Type", "Hard default", "Description"
+
+    "json_enabled", "bool", "True", "Output JSON logs using ``json_log_formatter``"
+    "log_file_path", "pathlib.Path", "./this.log", "Path and name of log file."
+    "file_rotation_size_megabytes", "int", "1", "Maximum size of "
+    "max_rotation_backup_files", "int", "10", "Maximum number of rotation backup files"
+
+
+Console logging
+---------------
+
+Console logging can be enabled or disabled, and there is an additional option
+to output line-by-line text based timestamped log entries, or JSON logging via
+the ``json_log_formatter`` framework. The format of text based log entries
+cannot be configured at this time and console logging is always emitted to
+stderr at this time.
+
+
+File logging
+------------
+
+File rotation on the file log is implemented as a "sensible default" - it cannot
+be disabled at this time, although you might be able to specify a maximum
+rotation of ``1`` to achieve the same end (not tested). The maximum rotation
+size can be specified as a configuration default. File logging itself can be
+enabled or disabled via defaults or the CLI options described above.
+
+Similar to console logging the format can be as either text-based or JSON
+logging.

click_logging_config-2.0.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+click_logging_config/VERSION,sha256=tLFvrqUtwEzP4y97NCCUhVkj6_WZo8rBlARwotbXwmE,6
+click_logging_config/__init__.py,sha256=ApTiqgsbFqWTVWw7C_i6dFHWEgVCDRnQ7OlZ6D9fOAw,146
+click_logging_config/_click.py,sha256=F3Rajiqzg6k--17Il3n0YNY8GK7728bu6HRpHuMw2q0,4896
+click_logging_config/_default_values.py,sha256=bvH2zWLZc-LtdoznV6xuPNhXGAmMlySqsaDEzSncR90,735
+click_logging_config/_logging.py,sha256=t1jz6sb9VmM7pF81tTiy_nk-aPEICIYWs43jvLa8TPk,7178
+click_logging_config/_version.py,sha256=bGmsJRW4pXXOBvC6FMYbVDMBgCE0gEsjhXfP1cjv_Dg,961
+click_logging_config/parameters.py,sha256=IRfUamM2yQbjp5c_TWVxQFu9xVvMmRQPgPjjVx0Ibfs,408
+click_logging_config/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+click_logging_config-2.0.2.dist-info/METADATA,sha256=tTT9ZnvwkHIjIWVjA0X1WRvHYMa2JF3qJoI-BjxlIJA,8613
+click_logging_config-2.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+click_logging_config-2.0.2.dist-info/licenses/LICENSE.txt,sha256=YtQuRK_6LysSNNjqInIn-ALBw_A3vqKc8M7K-2u06Dk,1103
+click_logging_config-2.0.2.dist-info/RECORD,,

click_logging_config-2.0.2.dist-info/WHEEL

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

click_logging_config-2.0.2.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright 2022 Russell Smiley
+
+MIT license https://opensource.org/licenses/MIT
+
+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.