bear-utils 0.7.23__tar.gz → 0.8.0__tar.gz

{bear_utils-0.7.23 → bear_utils-0.8.0}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.7.23
+current_version = 0.8.0
 
 [bumpversion:file:pyproject.toml]
 

{bear_utils-0.7.23 → bear_utils-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.7.23
+Version: 0.8.0
 Summary: Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things.
 Author-email: chaz <bright.lid5647@fastmail.com>
 Requires-Python: >=3.12
@@ -20,7 +20,7 @@ Requires-Dist: tinydb>=4.8.2
 Requires-Dist: toml>=0.10.2
 Description-Content-Type: text/markdown
 
-# Bear Utils v# Bear Utils v0.7.23
+# Bear Utils v# Bear Utils v0.8.0
 
 Personal set of tools and utilities for Python projects, focusing on modularity and ease of use. This library includes components for caching, database management, logging, time handling, file operations, CLI prompts, image processing, clipboard interaction, gradient utilities, event systems, and async helpers.
 

{bear_utils-0.7.23 → bear_utils-0.8.0}/README.md

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.7.23
+# Bear Utils v# Bear Utils v0.8.0
 
 Personal set of tools and utilities for Python projects, focusing on modularity and ease of use. This library includes components for caching, database management, logging, time handling, file operations, CLI prompts, image processing, clipboard interaction, gradient utilities, event systems, and async helpers.
 

{bear_utils-0.7.23 → bear_utils-0.8.0}/config/vscode/launch.json

@@ -14,22 +14,11 @@
             "name": "run",
             "type": "debugpy",
             "request": "launch",
-            "module": "trackdo",
+            "module": "bear-utils",
             "console": "integratedTerminal",
             "justMyCode": false,
             "args": "${command:pickArgs}"
         },
-        {
-            "name": "docs",
-            "type": "debugpy",
-            "request": "launch",
-            "module": "mkdocs",
-            "justMyCode": false,
-            "args": [
-                "serve",
-                "-v"
-            ]
-        },
         {
             "name": "test",
             "type": "debugpy",

{bear_utils-0.7.23 → bear_utils-0.8.0}/noxfile.py

@@ -5,6 +5,23 @@ import nox
 PYTHON_VERSIONS: list[str] = ["3.13", "3.14"]
 
 
+@nox.session(venv_backend="uv", tags=["lint", "fix"])
+def coverage(session: nox.Session) -> None:
+    """Run tests with coverage reporting."""
+    session.install("coverage[toml]", "pytest", "pytest-cov")
+    session.install("-e", ".")
+
+    session.run(
+        "pytest",
+        "--cov=src",
+        "--cov-report=term-missing",
+        "--cov-report=html",
+        "--cov-config=config/coverage.ini",
+    )
+
+    session.log("Coverage HTML report generated in htmlcov/")
+
+
 @nox.session(venv_backend="uv", tags=["lint"])
 def ruff_check(session: nox.Session) -> None:
     """Run ruff linting and formatting checks (CI-friendly, no changes)."""

{bear_utils-0.7.23 → bear_utils-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.7.23"
+version = "0.8.0"
 description = "Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things."
 authors = [{ name = "chaz", email = "bright.lid5647@fastmail.com" }]
 readme = "README.md"
@@ -29,9 +29,11 @@ build-backend = "hatchling.build"
 [dependency-groups]
 dev = [
     "bump2version>=1.0.1",
+    "coverage>=7.9.2",
     "isort>=6.0.1",
     "nox>=2025.5.1",
     "pytest>=8.3.5",
+    "pytest-cov>=6.2.1",
     "twine>=6.1.0",
 ]
 gui = [

bear_utils-0.8.0/src/bear_utils/__init__.py

@@ -0,0 +1,38 @@
+"""A module for Bear Utils, providing various utilities and tools."""
+
+from bear_epoch_time import EpochTimestamp, TimeTools
+
+from bear_utils.cache import CacheWrapper, cache, cache_factory
+from bear_utils.config.settings_manager import SettingsManager, get_settings_manager
+from bear_utils.constants.date_related import DATE_FORMAT, DATE_TIME_FORMAT
+from bear_utils.database import DatabaseManager
+from bear_utils.events import Events
+from bear_utils.extras.responses import FAILURE, SUCCESS, FunctionResponse
+from bear_utils.files.file_handlers.file_handler_factory import FileHandlerFactory
+from bear_utils.logger_manager import BaseLogger, BufferLogger, ConsoleLogger, FileLogger
+from bear_utils.logger_manager._common import VERBOSE_CONSOLE_FORMAT
+from bear_utils.logger_manager._styles import VERBOSE
+
+__all__ = [
+    "DATE_FORMAT",
+    "DATE_TIME_FORMAT",
+    "FAILURE",
+    "SUCCESS",
+    "VERBOSE",
+    "VERBOSE_CONSOLE_FORMAT",
+    "BaseLogger",
+    "BufferLogger",
+    "CacheWrapper",
+    "ConsoleLogger",
+    "DatabaseManager",
+    "EpochTimestamp",
+    "Events",
+    "FileHandlerFactory",
+    "FileLogger",
+    "FunctionResponse",
+    "SettingsManager",
+    "TimeTools",
+    "cache",
+    "cache_factory",
+    "get_settings_manager",
+]

bear_utils-0.8.0/src/bear_utils/__main__.py

@@ -0,0 +1,14 @@
+"""Entry-point module, in case you use `python -m bear_utils`.
+
+Why does this file exist, and why `__main__`? For more info, read:
+
+- https://www.python.org/dev/peps/pep-0338/
+- https://docs.python.org/3/using/cmdline.html#cmdoption-m
+"""
+
+import sys
+
+from bear_utils._internal.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

bear_utils-0.8.0/src/bear_utils/_internal/cli.py

@@ -0,0 +1,73 @@
+# Why does this file exist, and why not put this in `__main__`?
+#
+# You might be tempted to import things from `__main__` later,
+# but that will cause problems: the code will get executed twice:
+#
+# - When you run `python -m bear_utils` python will execute
+#   `__main__.py` as a script. That means there won't be any
+#   `bear_utils.__main__` in `sys.modules`.
+# - When you import `__main__` it will get executed again (as a module) because
+#   there's no `bear_utils.__main__` in `sys.modules`.
+from __future__ import annotations
+
+from argparse import Action, ArgumentParser, Namespace
+import sys
+from typing import Any
+
+from bear_utils._internal import debug
+
+
+class _DebugInfo(Action):
+    def __init__(self, nargs: int | str | None = 0, **kwargs: Any) -> None:
+        super().__init__(nargs=nargs, **kwargs)
+
+    def __call__(self, *_: Any, **__: Any) -> None:
+        debug._print_debug_info()
+        sys.exit(0)
+
+
+class _About(Action):
+    def __init__(self, nargs: int | str | None = 0, **kwargs: Any) -> None:
+        super().__init__(nargs=nargs, **kwargs)
+
+    def __call__(self, *_: Any, **__: Any) -> None:
+        print(debug._get_package_info())
+        sys.exit(0)
+
+
+def get_parser() -> ArgumentParser:
+    name: str = debug._get_name()
+    version: str = f"{name} v{debug._get_version()}"
+    parser = ArgumentParser(description=name.capitalize(), prog=name, exit_on_error=False)
+    parser.add_argument("-V", "--version", action="version", version=version)
+    parser.add_argument("--about", action=_About, help="Print information about the package")
+    parser.add_argument("--debug_info", action=_DebugInfo, help="Print debug information")
+    return parser
+
+
+def main(args: list[str] | None = None) -> int:
+    """Main entry point for the CLI.
+
+    This function is called when the CLI is executed. It can be used to
+    initialize the CLI, parse arguments, and execute commands.
+
+    Args:
+        args (list[str] | None): A list of command-line arguments. If None, uses sys.argv[1:].
+
+    Returns:
+        int: Exit code of the CLI execution. 0 for success, non-zero for failure.
+    """
+    if args is None:
+        args = sys.argv[1:]
+    try:
+        parser: ArgumentParser = get_parser()
+        opts: Namespace = parser.parse_args(args)
+        print(opts)
+    except Exception as e:
+        print(f"Error initializing CLI: {e}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    main()

bear_utils-0.8.0/src/bear_utils/_internal/debug.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import importlib.metadata
+from importlib.metadata import PackageNotFoundError, metadata, version
+import os
+import platform
+import sys
+
+__PACKAGE_NAME__ = "bear-utils"
+
+
+@dataclass
+class _Package:
+    """Dataclass to store package information."""
+
+    name: str = __PACKAGE_NAME__
+    """Package name."""
+    version: str = "0.0.0"
+    """Package version."""
+    description: str = "No description available."
+    """Package description."""
+
+    def __str__(self) -> str:
+        """String representation of the package information."""
+        return f"{self.name} v{self.version}: {self.description}"
+
+
+@dataclass
+class _Variable:
+    """Dataclass describing an environment variable."""
+
+    name: str
+    """Variable name."""
+    value: str
+    """Variable value."""
+
+
+@dataclass
+class _Environment:
+    """Dataclass to store environment information."""
+
+    interpreter_name: str
+    """Python interpreter name."""
+    interpreter_version: str
+    """Python interpreter version."""
+    interpreter_path: str
+    """Path to Python executable."""
+    platform: str
+    """Operating System."""
+    packages: list[_Package]
+    """Installed packages."""
+    variables: list[_Variable]
+    """Environment variables."""
+
+
+def _interpreter_name_version() -> tuple[str, str]:
+    if hasattr(sys, "implementation"):
+        impl = sys.implementation.version
+        version = f"{impl.major}.{impl.minor}.{impl.micro}"
+        kind = impl.releaselevel
+        if kind != "final":
+            version += kind[0] + str(impl.serial)
+        return sys.implementation.name, version
+    return "", "0.0.0"
+
+
+def _get_package_info(dist: str = __PACKAGE_NAME__) -> _Package:
+    try:
+        return _Package(
+            name=dist,
+            version=version(dist),
+            description=metadata(dist)["Summary"],
+        )
+    except PackageNotFoundError:
+        return _Package(name=dist)
+
+
+def _get_name(dist: str = __PACKAGE_NAME__) -> str:
+    """Get name of the given distribution.
+
+    Parameters:
+        dist: A distribution name.
+
+    Returns:
+        A package name.
+    """
+    return _get_package_info(dist).name
+
+
+def _get_version(dist: str = __PACKAGE_NAME__) -> str:
+    """Get version of the given distribution.
+
+    Parameters:
+        dist: A distribution name.
+
+    Returns:
+        A version number.
+    """
+    return _get_package_info(dist).version
+
+
+def _get_description(dist: str = __PACKAGE_NAME__) -> str:
+    """Get description of the given distribution.
+
+    Parameters:
+        dist: A distribution name.
+
+    Returns:
+        A description string.
+    """
+    return _get_package_info(dist).description
+
+
+def _get_debug_info() -> _Environment:
+    """Get debug/environment information.
+
+    Returns:
+        Environment information.
+    """
+    py_name, py_version = _interpreter_name_version()
+    packages: list[str] = [__PACKAGE_NAME__]
+    variables: list[str] = [
+        "PYTHONPATH",
+        *[var for var in os.environ if var.startswith(__PACKAGE_NAME__.replace("-", "_"))],
+    ]
+    return _Environment(
+        interpreter_name=py_name,
+        interpreter_version=py_version,
+        interpreter_path=sys.executable,
+        platform=platform.platform(),
+        variables=[_Variable(var, val) for var in variables if (val := os.getenv(var))],
+        packages=[_Package(pkg, _get_version(pkg)) for pkg in packages],
+    )
+
+
+def get_installed_packages() -> list[_Package]:
+    """Get all installed packages in current environment"""
+    packages = []
+    for dist in importlib.metadata.distributions():
+        packages.append({"name": dist.metadata["Name"], "version": dist.version})
+    return packages
+
+
+def _print_debug_info() -> None:
+    """Print debug/environment information."""
+    info: _Environment = _get_debug_info()
+    print(f"- __System__: {info.platform}")
+    print(f"- __Python__: {info.interpreter_name} {info.interpreter_version} ({info.interpreter_path})")
+    print("- __Environment variables__:")
+    for var in info.variables:
+        print(f"  - `{var.name}`: `{var.value}`")
+    print("- __Installed packages__:")
+    for pkg in info.packages:
+        print(f"  - `{pkg.name}` v{pkg.version}")
+
+
+if __name__ == "__main__":
+    _print_debug_info()

{bear_utils-0.7.23 → bear_utils-0.8.0}/src/bear_utils/ai/ai_helpers/__init__.py

@@ -5,7 +5,7 @@ from typing import Any, cast
 
 from rich.markdown import Markdown
 
-from bear_utils.logging import BaseLogger
+from bear_utils.logger_manager import BaseLogger
 
 from ._common import GPT_4_1_NANO, PRODUCTION_MODE, TESTING_MODE, AIModel, EnvironmentMode
 from ._config import AIEndpointConfig

{bear_utils-0.7.23 → bear_utils-0.8.0}/src/bear_utils/ai/ai_helpers/_types.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 
-from bear_utils.logging import BaseLogger
+from bear_utils.logger_manager import BaseLogger
 
 
 class ResponseParser[T_Response](ABC):

{bear_utils-0.7.23 → bear_utils-0.8.0}/src/bear_utils/cli/prompt_helpers.py

@@ -8,7 +8,7 @@ from prompt_toolkit.validation import ValidationError, Validator
 
 from bear_utils.constants._exceptions import UserCancelledError
 from bear_utils.constants._lazy_typing import LitBool, LitFloat, LitInt, LitStr, OptBool, OptFloat, OptInt, OptStr
-from bear_utils.logging.loggers import get_console
+from bear_utils.logger_manager import get_console
 
 # TODO: Overhaul this trash, it is written like absolute garbage.
 

{bear_utils-0.7.23 → bear_utils-0.8.0}/src/bear_utils/cli/shell/_base_shell.py

@@ -14,7 +14,7 @@ from subprocess import CompletedProcess
 from typing import Self, override
 
 from bear_utils.constants.logger_protocol import LoggerProtocol
-from bear_utils.logging import VERBOSE, BaseLogger, SubConsoleLogger
+from bear_utils.logger_manager import VERBOSE, BaseLogger, SubConsoleLogger
 
 from ._base_command import BaseShellCommand
 from ._common import DEFAULT_SHELL

{bear_utils-0.7.23 → bear_utils-0.8.0}/src/bear_utils/config/settings_manager.py

@@ -9,11 +9,11 @@ from typing import Any, Self
 from tinydb import Query, TinyDB
 
 
-def get_bear_config_path() -> Path:
-    """Get the path to the bear configuration path"""
-    path: Path = Path.home() / ".config" / "bear_utils"
-    path.mkdir(parents=True, exist_ok=True)
-    return path
+def get_config_folder() -> Path:
+    """Get the path to the bear configuration directory."""
+    config_path: Path = Path.home() / ".bear_utils"
+    config_path.mkdir(parents=True, exist_ok=True)
+    return config_path
 
 
 class SettingsManager:
@@ -21,11 +21,12 @@ class SettingsManager:
 
     __slots__ = ("cache", "db", "file_path", "settings_name")
 
-    def __init__(self, settings_name: str) -> None:
+    def __init__(self, settings_name: str, folder_path: str | Path | None = None) -> None:
         """Initialize the SettingsManager with a specific settings name."""
-        self.settings_name = settings_name
+        self.settings_name: str = settings_name
         self.cache: dict[str, Any] = {}
-        self.file_path: Path = get_bear_config_path() / f"{settings_name}.json"
+        file_name: str = f"{settings_name}.json"
+        self.file_path: Path = Path(folder_path) / file_name if folder_path else get_config_folder() / file_name
         self.db: TinyDB = TinyDB(self.file_path, indent=4, ensure_ascii=False)
 
         atexit.register(self.close)

{bear_utils-0.7.23 → bear_utils-0.8.0}/src/bear_utils/extras/_tools.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING
 from bear_utils.cli.shell._base_command import BaseShellCommand as ShellCommand
 from bear_utils.cli.shell._base_shell import AsyncShellSession
 from bear_utils.extras.platform_utils import OS, get_platform
-from bear_utils.logging.logger_manager.loggers._base_logger import BaseLogger
+from bear_utils.logger_manager.loggers._base_logger import BaseLogger
 
 if TYPE_CHECKING:
     from subprocess import CompletedProcess
@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 class TextHelper:
     @cached_property
     def local_console(self) -> BaseLogger:
-        from bear_utils.logging.loggers import BaseLogger  # noqa: PLC0415
+        from bear_utils.logger_manager import BaseLogger  # noqa: PLC0415
 
         init: bool = not BaseLogger.has_instance()
         return BaseLogger.get_instance(init=init)

bear_utils-0.8.0/src/bear_utils/extras/responses/__init__.py

@@ -0,0 +1,9 @@
+"""A module for handling responses for functions, methods, and classes in Bear Utils."""
+
+from .function_response import FAILURE, SUCCESS, FunctionResponse
+
+__all__ = [
+    "FAILURE",
+    "SUCCESS",
+    "FunctionResponse",
+]

{bear_utils-0.7.23 → bear_utils-0.8.0}/src/bear_utils/extras/responses/function_response.py

@@ -5,12 +5,11 @@ from __future__ import annotations
 from io import StringIO
 import json
 from subprocess import CompletedProcess
-from typing import TYPE_CHECKING, Any, Literal, Self, overload
+from typing import Any, Literal, Self, overload
 
 from pydantic import BaseModel, Field, field_validator
 
-if TYPE_CHECKING:
-    from bear_utils.constants.logger_protocol import LoggerProtocol
+from bear_utils.constants.logger_protocol import LoggerProtocol  # noqa: TC001 # DO NOT PUT INTO A TYPE_CHECKING BLOCK
 
 SUCCESS: list[str] = ["name", "success"]
 FAILURE: list[str] = ["name"]
@@ -130,6 +129,25 @@ class FunctionResponse(BaseModel):
         """Check if the response indicates success."""
         return self.returncode == 0
 
+    def sub_task(
+        self,
+        name: str = "",
+        content: str | list[str] = "",
+        error: str | list[str] = "",
+        extra: dict[str, Any] | None = None,
+        returncode: int | None = None,
+        log_output: bool = False,
+    ) -> None:
+        """Add a sub-task response to the FunctionResponse."""
+        func_response: FunctionResponse = FunctionResponse(name=name, logger=self.logger).add(
+            content=content,
+            error=error,
+            returncode=returncode or self.returncode,
+            log_output=log_output,
+            extra=extra,
+        )
+        self.add(content=func_response)
+
     def successful(
         self,
         content: str | list[str] | CompletedProcess,
@@ -184,6 +202,19 @@ class FunctionResponse(BaseModel):
         except Exception as e:
             raise ValueError(f"Failed to add content: {e!s}") from e
 
+    def _handle_function_response(self, func_response: FunctionResponse) -> None:
+        """Handle a FunctionResponse object and update the current response."""
+        if func_response.extra:
+            self.extra.update(func_response.extra)
+        self._add_to_error(error=func_response.error, name=func_response.name)
+        self._add_to_content(content=func_response.content, name=func_response.name)
+
+    def _handle_completed_process(self, result: CompletedProcess[str]) -> None:
+        """Handle a CompletedProcess object and update the FunctionResponse."""
+        self._add_to_content(content=result.stdout.strip() if result.stdout else "")
+        self._add_to_error(error=result.stderr.strip() if result.stderr else "")
+        self.returncode = result.returncode
+
     def add(
         self,
         content: list[str] | str | FunctionResponse | CompletedProcess | None = None,
@@ -205,45 +236,49 @@ class FunctionResponse(BaseModel):
             Self: The updated FunctionResponse instance.
         """
         try:
-            if isinstance(content, FunctionResponse):
-                if content.extra:
-                    self.extra.update(content.extra)
-                self._add_to_error(error=content.error, name=content.name)
-                self._add_to_content(content=content.content, name=content.name)
-                self.number_of_tasks += 1
-            elif isinstance(content, CompletedProcess):
-                result: CompletedProcess[str] = content
-                self._add_to_content(content=result.stdout.strip() if result.stdout else "")
-                self._add_to_error(error=result.stderr.strip() if result.stderr else "")
-                self.returncode = result.returncode
-                self.number_of_tasks += 1
-            elif isinstance(content, str | list):
-                self._add_to_content(content=content)
-                self.number_of_tasks += 1
-            if isinstance(error, str | list):
-                self._add_to_error(error=error)
-            if returncode is not None:
-                self.returncode = returncode
-            if extra is not None and isinstance(extra, dict):
-                self.extra.update(extra)
-            if log_output and self.logger is not None:
-                if content is not None and error is None:
-                    if isinstance(content, list):
-                        for item in content:
-                            self.logger.info(message=f"{self.name}: {item}" if self.name else item)
-                    elif isinstance(content, str):
-                        self.logger.info(message=f"{self.name}: {content}" if self.name else content)
-                elif error is not None and content is None:
-                    if isinstance(error, list):
-                        for err in error:
-                            self.logger.error(message=f"{self.name}: {err}" if self.name else err)
-                    elif isinstance(error, str):
-                        self.logger.error(message=f"{self.name}: {error}" if self.name else error)
-
+            match content:
+                case FunctionResponse():
+                    self._handle_function_response(func_response=content)
+                    self.number_of_tasks += 1
+                case CompletedProcess():
+                    self._handle_completed_process(result=content)
+                    self.number_of_tasks += 1
+                case str() | list() if content:
+                    self._add_to_content(content=content)
+                    self.number_of_tasks += 1
+                case None:
+                    content = None
+                case _:
+                    content = None
+            self._add_to_error(error=error) if isinstance(error, (str | list)) else None
+            self.returncode = returncode if returncode is not None else self.returncode
+            self.extra.update(extra) if isinstance(extra, dict) else None
+            if log_output and self.logger is not None and (content is not None or error is not None):
+                self._log_handling(content=content, error=error, logger=self.logger)
         except Exception as e:
             raise ValueError(f"Failed to add content: {e!s}") from e
         return self
 
+    def _log_handling(
+        self,
+        content: list[str] | str | FunctionResponse | CompletedProcess | None,
+        error: str | list[str] | None,
+        logger: LoggerProtocol,
+    ) -> None:
+        """Log the content and error messages if they exist."""
+        if content is not None and error is None:
+            if isinstance(content, list):
+                for item in content:
+                    logger.info(message=f"{self.name}: {item}" if self.name else item)
+            elif isinstance(content, str):
+                logger.info(message=f"{self.name}: {content}" if self.name else content)
+        elif error is not None and content is None:
+            if isinstance(error, list):
+                for err in error:
+                    logger.error(message=f"{self.name}: {err}" if self.name else err)
+            elif isinstance(error, str):
+                logger.error(message=f"{self.name}: {error}" if self.name else error)
+
     @overload
     def done(self, to_dict: Literal[True], suppress: list[str] | None = None) -> dict[str, Any]: ...
 

{bear_utils-0.7.23 → bear_utils-0.8.0}/src/bear_utils/files/file_handlers/_base_file_handler.py

@@ -8,12 +8,6 @@ P = ParamSpec("P")
 R = TypeVar("R")
 
 
-def check_data_type(data: dict[str, Any] | str, valid_types: tuple[type, ...]) -> None:
-    """Check if the data is of a valid type for text files."""
-    if not isinstance(data, valid_types):
-        raise TypeError(f"Data must be one of {valid_types}, got {type(data)}")
-
-
 class FileHandler(ABC):
     """Abstract class for file handling with read, write, and present methods
 
@@ -40,7 +34,7 @@ class FileHandler(ABC):
         return file_path.suffix.lstrip(".") in cls.valid_extensions
 
     @classmethod
-    def check_data_type(cls, data: Any) -> Any:
+    def check_data_type(cls, data: dict[str, Any] | str, valid_types: tuple[type, ...]) -> None:
         """Check if the data is of the correct type.
 
         Args:
@@ -49,8 +43,8 @@ class FileHandler(ABC):
         Returns:
             bool: True if the data is of the correct type, False otherwise
         """
-        if not isinstance(data, cls.valid_types):
-            raise TypeError(f"Data must be one of {cls.valid_types}, got {type(data)}")
+        if not isinstance(data, valid_types):
+            raise TypeError(f"Data must be one of {valid_types}, got {type(data)}")
 
     @classmethod
     def ValidateFileType(cls, method: Callable[P, R]) -> Callable[P, R]:  # noqa: N802 disable=invalid-name