bear-utils 0.7.21__py3-none-any.whl → 0.7.23__py3-none-any.whl

bear_utils/extras/_tools.py

@@ -1,29 +1,40 @@
 import asyncio
-import shutil
 from asyncio.subprocess import PIPE
 from collections import deque
 from functools import cached_property
-from subprocess import CompletedProcess
+import shutil
+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 ..cli.shell._base_command import BaseShellCommand as ShellCommand
-from ..cli.shell._base_shell import AsyncShellSession
-from ..logging.logger_manager.loggers._base_logger import BaseLogger
-from .platform_utils import OS, get_platform
+if TYPE_CHECKING:
+    from subprocess import CompletedProcess
 
 
 class TextHelper:
     @cached_property
     def local_console(self) -> BaseLogger:
-        from ..logging.loggers import BaseLogger
+        from bear_utils.logging.loggers import BaseLogger  # noqa: PLC0415
 
         init: bool = not BaseLogger.has_instance()
         return BaseLogger.get_instance(init=init)
 
-    def print_header(self, title: str, sep="#", len=60, s1="bold red", s2="bold blue", return_txt: bool = False) -> str:
+    def print_header(
+        self,
+        title: str,
+        sep: str = "#",
+        length: int = 60,
+        s1: str = "bold red",
+        s2: str = "bold blue",
+        return_txt: bool = False,
+    ) -> str:
         """Generate a header string"""
         # FIXME: There are probably better ways to do this, but this is OK.
-        fill: str = sep * len
-        title = f" {title} ".center(len, sep).replace(title, f"[{s1}]{title}[/{s1}]")
+        fill: str = sep * length
+        title = f" {title} ".center(length, sep).replace(title, f"[{s1}]{title}[/{s1}]")
         output_text: str = f"\n{fill}\n{title}\n{fill}\n"
         if not return_txt:
             self.local_console.print(output_text, style=s2)
@@ -31,13 +42,14 @@ class TextHelper:
 
 
 class ClipboardManager:
-    """
-    A class to manage clipboard operations such as copying, pasting, and clearing.
+    """A class to manage clipboard operations such as copying, pasting, and clearing.
+
     This class provides methods to interact with the system clipboard.
     """
 
     def __init__(self, maxlen: int = 10) -> None:
-        self.clipboard_history = deque(maxlen=maxlen)
+        """Initialize the ClipboardManager with a maximum history length."""
+        self.clipboard_history: deque[str] = deque(maxlen=maxlen)
         self.shell = AsyncShellSession(env={"LANG": "en_US.UTF-8"}, verbose=False)
         self._copy: ShellCommand[str]
         self._paste: ShellCommand[str]
@@ -45,23 +57,31 @@ class ClipboardManager:
         platform: OS = get_platform()
         match platform:
             case OS.DARWIN:
-                self._copy = ShellCommand.adhoc("pbcopy")
-                self._paste = ShellCommand.adhoc("pbpaste")
+                self._copy = ShellCommand.adhoc(name="pbcopy")
+                self._paste = ShellCommand.adhoc(name="pbpaste")
             case OS.LINUX:
-                if shutil.which("wl-copy") and shutil.which("wl-paste"):
-                    self._copy = ShellCommand.adhoc("wl-copy")
-                    self._paste = ShellCommand.adhoc("wl-paste")
-                elif shutil.which("xclip"):
-                    self._copy = ShellCommand.adhoc("xclip").sub("-selection", "clipboard")
-                    self._paste = ShellCommand.adhoc("xclip").sub("-selection", "clipboard").value("-o")
+                if shutil.which(cmd="wl-copy") and shutil.which(cmd="wl-paste"):
+                    self._copy = ShellCommand.adhoc(name="wl-copy")
+                    self._paste = ShellCommand.adhoc(name="wl-paste")
+                elif shutil.which(cmd="xclip"):
+                    self._copy = ShellCommand.adhoc(name="xclip").sub("-selection", "clipboard")
+                    self._paste = ShellCommand.adhoc(name="xclip").sub("-selection", "clipboard").value("-o")
                 else:
                     raise RuntimeError("No clipboard command found on Linux")
             case OS.WINDOWS:
-                self._copy = ShellCommand.adhoc("clip")
-                self._paste = ShellCommand.adhoc("powershell").sub("Get-Clipboard")
+                self._copy = ShellCommand.adhoc(name="clip")
+                self._paste = ShellCommand.adhoc(name="powershell").sub("Get-Clipboard")
             case _:
                 raise RuntimeError(f"Unsupported platform: {platform}")
 
+    def _copy_cmd(self) -> ShellCommand[str]:
+        """Get the copy command based on the platform."""
+        return self._copy
+
+    def _paste_cmd(self) -> ShellCommand[str]:
+        """Get the paste command based on the platform."""
+        return self._paste
+
     def get_history(self) -> deque:
         """Get the clipboard history.
 
@@ -71,8 +91,7 @@ class ClipboardManager:
         return self.clipboard_history
 
     async def copy(self, output: str) -> int:
-        """
-        A function that copies the output to the clipboard.
+        """A function that copies the output to the clipboard.
 
         Args:
             output (str): The output to copy to the clipboard.
@@ -80,15 +99,14 @@ class ClipboardManager:
         Returns:
             int: The return code of the command.
         """
-        await self.shell.run(self._copy, stdin=PIPE)
+        await self.shell.run(cmd=self._copy, stdin=PIPE)
         result: CompletedProcess[str] = await self.shell.communicate(stdin=output)
         if result.returncode == 0:
             self.clipboard_history.append(output)  # Only append to history if the copy was successful
         return result.returncode
 
     async def paste(self) -> str:
-        """
-        Paste the output from the clipboard.
+        """Paste the output from the clipboard.
 
         Returns:
             str: The content of the clipboard.
@@ -97,27 +115,25 @@ class ClipboardManager:
             RuntimeError: If the paste command fails.
         """
         try:
-            await self.shell.run(self._paste)
+            await self.shell.run(cmd=self._paste)
             result: CompletedProcess[str] = await self.shell.communicate()
-        except Exception as e:  # pragma: no cover - safety net for unforeseen shell errors
+        except Exception as e:
             raise RuntimeError(f"Error pasting from clipboard: {e}") from e
         if result.returncode != 0:
             raise RuntimeError(f"{self._paste.cmd} failed with return code {result.returncode}")
         return result.stdout
 
     async def clear(self) -> int:
-        """
-        A function that clears the clipboard.
+        """A function that clears the clipboard.
 
         Returns:
             int: The return code of the command.
         """
-        return await self.copy("")
+        return await self.copy(output="")
 
 
 def copy_to_clipboard(output: str) -> int:
-    """
-    Copy the output to the clipboard.
+    """Copy the output to the clipboard.
 
     Args:
         output (str): The output to copy to the clipboard.
@@ -127,12 +143,11 @@ def copy_to_clipboard(output: str) -> int:
     """
     clipboard_manager = ClipboardManager()
     loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()
-    return loop.run_until_complete(clipboard_manager.copy(output))
+    return loop.run_until_complete(future=clipboard_manager.copy(output))
 
 
 async def copy_to_clipboard_async(output: str) -> int:
-    """
-    Asynchronously copy the output to the clipboard.
+    """Asynchronously copy the output to the clipboard.
 
     Args:
         output (str): The output to copy to the clipboard.
@@ -141,24 +156,22 @@ async def copy_to_clipboard_async(output: str) -> int:
         int: The return code of the command.
     """
     clipboard_manager = ClipboardManager()
-    return await clipboard_manager.copy(output)
+    return await clipboard_manager.copy(output=output)
 
 
 def paste_from_clipboard() -> str:
-    """
-    Paste the output from the clipboard.
+    """Paste the output from the clipboard.
 
     Returns:
         str: The content of the clipboard.
     """
     clipboard_manager = ClipboardManager()
     loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()
-    return loop.run_until_complete(clipboard_manager.paste())
+    return loop.run_until_complete(future=clipboard_manager.paste())
 
 
 async def paste_from_clipboard_async() -> str:
-    """
-    Asynchronously paste the output from the clipboard.
+    """Asynchronously paste the output from the clipboard.
 
     Returns:
         str: The content of the clipboard.
@@ -168,8 +181,7 @@ async def paste_from_clipboard_async() -> str:
 
 
 def clear_clipboard() -> int:
-    """
-    Clear the clipboard.
+    """Clear the clipboard.
 
     Returns:
         int: The return code of the command.
@@ -180,8 +192,7 @@ def clear_clipboard() -> int:
 
 
 async def clear_clipboard_async() -> int:
-    """
-    Asynchronously clear the clipboard.
+    """Asynchronously clear the clipboard.
 
     Returns:
         int: The return code of the command.
@@ -198,8 +209,7 @@ def fmt_header(
     style2: str = "bold blue",
     print_out: bool = True,
 ) -> str:
-    """
-    Generate a header string for visual tests.
+    """Generate a header string for visual tests.
 
     Args:
         title (str): The title to display in the header.
@@ -210,6 +220,6 @@ def fmt_header(
     """
     text_helper = TextHelper()
     if print_out:
-        text_helper.print_header(title, sep, length, style1, style2, return_txt=False)
+        text_helper.print_header(title=title, sep=sep, length=length, s1=style1, s2=style2, return_txt=False)
         return ""
-    return text_helper.print_header(title, sep, length, style1, style2, return_txt=True)
+    return text_helper.print_header(title=title, sep=sep, length=length, s1=style1, s2=style2, return_txt=True)

bear_utils/extras/platform_utils.py

@@ -1,8 +1,12 @@
-import platform
+"""A module for detecting the current operating system."""
+
 from enum import StrEnum
+import platform
 
 
 class OS(StrEnum):
+    """Enumeration of operating systems."""
+
     DARWIN = "Darwin"
     LINUX = "Linux"
     WINDOWS = "Windows"

bear_utils/extras/responses/__init__.py

@@ -0,0 +1 @@
+"""A module for handling responses for functions, methods, and classes in Bear Utils."""

bear_utils/extras/responses/function_response.py

@@ -0,0 +1,301 @@
+"""Function Response Class for handling function call results."""
+
+from __future__ import annotations
+
+from io import StringIO
+import json
+from subprocess import CompletedProcess
+from typing import TYPE_CHECKING, Any, Literal, Self, overload
+
+from pydantic import BaseModel, Field, field_validator
+
+if TYPE_CHECKING:
+    from bear_utils.constants.logger_protocol import LoggerProtocol
+
+SUCCESS: list[str] = ["name", "success"]
+FAILURE: list[str] = ["name"]
+
+
+class FunctionResponse(BaseModel):
+    """A class to represent the response of a function call, including success status, content, and error messages."""
+
+    name: str = Field(default="", description="Name of the function that was called.")
+    returncode: int = Field(default=0, description="Return code of the function, 0 for success, !=0 for failure.")
+    extra: dict = Field(default_factory=dict, description="Additional metadata or information related to the response.")
+    content: list[str] = Field(default=[], description="Content returned by the function call")
+    error: list[str] = Field(default=[], description="Error message if the function call failed")
+    number_of_tasks: int = Field(default=0, description="Number of tasks processed in this response.")
+    logger: LoggerProtocol | None = Field(default=None, description="Logger instance for logging messages.")
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+    }
+
+    def __repr__(self) -> str:
+        """Return a string representation of Response."""
+        result = StringIO()
+        result.write("Response(")
+        if self.name:
+            result.write(f"name={self.name!r}, ")
+        if self.returncode:
+            result.write(f"success={self.success!r}, ")
+        if self.content:
+            content: str = ", ".join(self.content)
+            result.write(f"content={content!r}, ")
+        if self.error:
+            error: str = ", ".join(self.error)
+            result.write(f"error={error!r}, ")
+        if self.extra:
+            result.write(f"extra={json.dumps(self.extra)!r}, ")
+        if self.number_of_tasks > 0:
+            result.write(f"number_of_tasks={self.number_of_tasks!r}, ")
+        result.write(")")
+        returned_result: str = result.getvalue().replace(", )", ")")
+        result.close()
+        return returned_result
+
+    def __str__(self) -> str:
+        """Return a string representation of Response."""
+        return self.__repr__()
+
+    @field_validator("name", mode="before")
+    @classmethod
+    def validate_name(cls, value: str | Any) -> str:
+        """Ensure name is a string, lowercased, and without spaces."""
+        if value is None:
+            return ""
+        if not isinstance(value, str):
+            try:
+                value = str(value)
+            except Exception as e:
+                raise TypeError(f"Name must be a string, got {type(value).__name__}.") from e
+        return value.lower().replace(" ", "_")
+
+    @field_validator("returncode")
+    @classmethod
+    def validate_returncode(cls, value: int) -> int:
+        """Ensure returncode is an integer above or equal to zero."""
+        if not isinstance(value, int) or value < 0:
+            raise ValueError("Return code must be a non-negative integer.")
+        return value
+
+    @field_validator("extra", mode="before")
+    @classmethod
+    def validate_extra(cls, value: dict | Any) -> dict:
+        """Ensure extra is always a dictionary."""
+        if value is None:
+            return {}
+        if not isinstance(value, dict):
+            raise TypeError("Extra must be a dictionary.")
+        return value
+
+    @field_validator("content", mode="before")
+    @classmethod
+    def validate_content(cls, value: str | list[str] | Any) -> list[str]:
+        """Ensure content is always a list of strings."""
+        if isinstance(value, str):
+            return [value]
+        if isinstance(value, list):
+            if not all(isinstance(item, str) for item in value):
+                raise TypeError("Content must be a list of strings.")
+            return value
+        raise TypeError("Content must be a string or a list of strings.")
+
+    @field_validator("error", mode="before")
+    @classmethod
+    def validate_error(cls, value: str | list[str] | Any) -> list[str]:
+        """Ensure error is always a list of strings."""
+        if isinstance(value, str):
+            return [value]
+        if isinstance(value, list):
+            if not all(isinstance(item, str) for item in value):
+                raise TypeError("Error must be a list of strings.")
+            return value
+        raise TypeError("Error must be a string or a list of strings.")
+
+    @classmethod
+    def from_process(cls, process: CompletedProcess[str], **kwargs) -> Self:
+        """Create a FunctionResponse from a CompletedProcess object."""
+        returncode: int = process.returncode if process.returncode is not None else 0
+        content: str = process.stdout.strip() if process.stdout else ""
+        error: str = process.stderr.strip() if process.stderr else ""
+
+        if returncode == 0 and not content and error:
+            error, content = content, error
+
+        return cls().add(returncode=returncode, content=content, error=error, **kwargs)
+
+    @property
+    def success(self) -> bool:
+        """Check if the response indicates success."""
+        return self.returncode == 0
+
+    def successful(
+        self,
+        content: str | list[str] | CompletedProcess,
+        error: str | list[str] = "",
+        returncode: int | None = None,
+        **kwargs,
+    ) -> Self:
+        """Set the response to a success state with optional content."""
+        self.add(content=content, error=error, returncode=returncode or 0, **kwargs)
+        return self
+
+    def fail(
+        self,
+        content: list[str] | str | CompletedProcess = "",
+        error: str | list[str] = "",
+        returncode: int | None = None,
+        **kwargs,
+    ) -> Self:
+        """Set the response to a failure state with an error message."""
+        self.add(content=content, error=error, returncode=returncode or 1, **kwargs)
+        return self
+
+    def _add_error(self, error: str) -> None:
+        """Append an error message to the existing error."""
+        if error != "":
+            self.error.append(error)
+
+    def _add_to_error(self, error: str | list[str], name: str | None = None) -> None:
+        """Append additional error messages to the existing error."""
+        try:
+            if isinstance(error, list):
+                for err in error:
+                    self._add_error(error=f"{name}: {err}" if name else err)
+            elif isinstance(error, str):
+                self._add_error(error=f"{name}: {error}" if name else error)
+        except Exception as e:
+            raise ValueError(f"Failed to add error: {e!s}") from e
+
+    def _add_content(self, content: str) -> None:
+        """Append content to the existing content."""
+        if content != "":
+            self.content.append(content)
+
+    def _add_to_content(self, content: str | list[str], name: str | None = None) -> None:
+        """Append additional content to the existing content."""
+        try:
+            if isinstance(content, list):
+                for item in content:
+                    self._add_content(content=f"{name}: {item}" if name else item)
+            elif isinstance(content, str):
+                self._add_content(content=f"{name}: {content}" if name else content)
+        except Exception as e:
+            raise ValueError(f"Failed to add content: {e!s}") from e
+
+    def add(
+        self,
+        content: list[str] | str | FunctionResponse | CompletedProcess | None = None,
+        error: str | list[str] | None = None,
+        returncode: int | None = None,
+        log_output: bool = False,
+        extra: dict[str, Any] | None = None,
+    ) -> Self:
+        """Append additional content to the existing content.
+
+        Args:
+            content (list[str] | str | FunctionResponse | CompletedProcess): The content to add.
+            error (str | list[str] | None): The error message(s) to add.
+            returncode (int | None): The return code of the function call.
+            log_output (bool): Whether to log the output using the logger.
+            **kwargs: Additional metadata to include in the response.
+
+        Returns:
+            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)
+
+        except Exception as e:
+            raise ValueError(f"Failed to add content: {e!s}") from e
+        return self
+
+    @overload
+    def done(self, to_dict: Literal[True], suppress: list[str] | None = None) -> dict[str, Any]: ...
+
+    @overload
+    def done(self, to_dict: Literal[False], suppress: list[str] | None = None) -> Self: ...
+
+    def done(self, to_dict: bool = False, suppress: list[str] | None = None) -> dict[str, Any] | Self:
+        """Convert the FunctionResponse to a dictionary or return the instance itself.
+
+        Args:
+            to_dict (bool): If True, return a dictionary representation.
+            If False, return the FunctionResponse instance.
+
+        Returns:
+            dict[str, Any] | Self: The dictionary representation or the FunctionResponse instance.
+        """
+        if suppress is None:
+            suppress = []
+        if to_dict:
+            result: dict[str, Any] = {}
+            if self.name and "name" not in suppress:
+                result["name"] = self.name
+            if "success" not in suppress:
+                result.update({"success": self.success})
+            if self.returncode > 0 and "returncode" not in suppress:
+                result["returncode"] = self.returncode
+            if self.number_of_tasks > 0 and "number_of_tasks" not in suppress:
+                result["number_of_tasks"] = self.number_of_tasks
+            if self.content and "content" not in suppress:
+                result["content"] = self.content
+            if self.error and "error" not in suppress:
+                result["error"] = self.error
+            if self.extra:
+                result.update(self.extra)
+            return result
+        return self
+
+
+def success(
+    content: str | list[str] | CompletedProcess[str] | FunctionResponse,
+    error: str = "",
+    **kwargs,
+) -> FunctionResponse:
+    """Create a successful FunctionResponse."""
+    return FunctionResponse().add(content=content, error=error, **kwargs)
+
+
+def fail(
+    content: str | list[str] | CompletedProcess[str] = "",
+    error: str | list[str] = "",
+    returncode: int | None = None,
+    **kwargs,
+) -> FunctionResponse:
+    """Create a failed FunctionResponse."""
+    return FunctionResponse().fail(content=content, error=error, returncode=returncode, **kwargs)

bear_utils/extras/wrappers/__init__.py

@@ -0,0 +1 @@
+"""A module for wrappers in Bear Utils."""

bear_utils/extras/wrappers/add_methods.py

@@ -1,3 +1,5 @@
+"""A module for adding rich comparison methods to classes based on an attribute."""
+
 from collections.abc import Callable
 from types import NotImplementedType
 from typing import Any, TypeVar
@@ -29,7 +31,7 @@ def add_comparison_methods(attribute: str) -> Callable[[type[T]], type[T]]:
     """
 
     def decorator(cls: type[T]) -> type[T]:
-        def extract_comparable_value(self, other: Any) -> NotImplementedType | Any:
+        def extract_comparable_value(self: object, other: Any) -> NotImplementedType | Any:  # noqa: ARG001
             """Helper to extract the comparable value from the other object."""
             if isinstance(other, PRIMITIVE_TYPES):
                 return other
@@ -39,59 +41,59 @@ def add_comparison_methods(attribute: str) -> Callable[[type[T]], type[T]]:
 
             return NotImplemented
 
-        def equals_method(self, other: Any) -> NotImplementedType | bool:
+        def equals_method(self: object, other: Any) -> NotImplementedType | bool:
             """Equal comparison method (__eq__)."""
             other_val: NotImplementedType | Any = extract_comparable_value(self, other)
             if other_val is NotImplemented:
                 return NotImplemented
             return getattr(self, attribute) == other_val
 
-        def not_equals_method(self, other: Any) -> NotImplementedType | bool:
+        def not_equals_method(self: object, other: Any) -> NotImplementedType | bool:
             """Not equal comparison method (__ne__)."""
             other_val: NotImplementedType | Any = extract_comparable_value(self, other)
             if other_val is NotImplemented:
                 return NotImplemented
             return getattr(self, attribute) != other_val
 
-        def less_than_method(self, other: Any) -> NotImplementedType | bool:
+        def less_than_method(self: object, other: Any) -> NotImplementedType | bool:
             """Less than comparison method (__lt__)."""
             other_val: NotImplementedType | Any = extract_comparable_value(self, other)
             if other_val is NotImplemented:
                 return NotImplemented
             return getattr(self, attribute) < other_val
 
-        def greater_than_method(self, other: Any) -> NotImplementedType | bool:
+        def greater_than_method(self: object, other: Any) -> NotImplementedType | bool:
             """Greater than comparison method (__gt__)."""
             other_val: NotImplementedType | Any = extract_comparable_value(self, other)
             if other_val is NotImplemented:
                 return NotImplemented
             return getattr(self, attribute) > other_val
 
-        def less_than_or_equal_method(self, other: Any) -> NotImplementedType | bool:
+        def less_than_or_equal_method(self: object, other: Any) -> NotImplementedType | bool:
             """Less than or equal comparison method (__le__)."""
             other_val: NotImplementedType | Any = extract_comparable_value(self, other)
             if other_val is NotImplemented:
                 return NotImplemented
             return getattr(self, attribute) <= other_val
 
-        def greater_than_or_equal_method(self, other: Any) -> NotImplementedType | bool:
+        def greater_than_or_equal_method(self: object, other: Any) -> NotImplementedType | bool:
             """Greater than or equal comparison method (__ge__)."""
             other_val: NotImplementedType | Any = extract_comparable_value(self, other)
             if other_val is NotImplemented:
                 return NotImplemented
             return getattr(self, attribute) >= other_val
 
-        def hash_method(self) -> int:
+        def hash_method(self: object) -> int:
             """Generate hash based on the attribute used for equality."""
             return hash(getattr(self, attribute))
 
-        setattr(cls, "__eq__", equals_method)
-        setattr(cls, "__ne__", not_equals_method)
-        setattr(cls, "__lt__", less_than_method)
-        setattr(cls, "__gt__", greater_than_method)
-        setattr(cls, "__le__", less_than_or_equal_method)
-        setattr(cls, "__ge__", greater_than_or_equal_method)
-        setattr(cls, "__hash__", hash_method)
+        cls.__eq__ = equals_method
+        cls.__ne__ = not_equals_method
+        cls.__lt__ = less_than_method  # type: ignore[assignment]
+        cls.__gt__ = greater_than_method  # type: ignore[assignment]
+        cls.__le__ = less_than_or_equal_method  # type: ignore[assignment]
+        cls.__ge__ = greater_than_or_equal_method  # type: ignore[assignment]
+        cls.__hash__ = hash_method
 
         return cls
 

bear_utils/files/__init__.py

@@ -1,4 +1,6 @@
+"""A module for file handling utilities in Bear Utils."""
+
 from .file_handlers import FileHandlerFactory
 from .ignore_parser import IGNORE_PATTERNS
 
-__all__ = ["FileHandlerFactory", "IGNORE_PATTERNS"]
+__all__ = ["IGNORE_PATTERNS", "FileHandlerFactory"]