bear-utils 0.8.6__py3-none-any.whl → 0.8.7__py3-none-any.whl

bear_utils/cli/prompt_helpers.py

@@ -7,37 +7,60 @@ from prompt_toolkit.completion import WordCompleter
 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.constants._lazy_typing import OptBool, OptFloat, OptInt, OptStr
 from bear_utils.logger_manager import get_console
 
-# TODO: Overhaul this trash, it is written like absolute garbage.
+# TODO: ehhhhhhhh, it is okay
+
+
+def _parse_bool(value: str) -> bool:
+    """Parse a string into a boolean value."""
+    lower_value: str = value.lower().strip()
+    if lower_value in ("true", "t", "yes", "y", "1"):
+        return True
+    if lower_value in ("false", "f", "no", "n", "0"):
+        return False
+    raise ValueError(f"Cannot convert '{value}' to boolean")
+
+
+def _convert_value(value: str, target_type: type) -> str | int | float | bool:
+    """Convert a string value to the target type."""
+    if target_type is str:
+        return value
+    if target_type is int:
+        return int(value)
+    if target_type is float:
+        return float(value)
+    if target_type is bool:
+        return _parse_bool(value)
+    raise ValueError(f"Unsupported type: {target_type}")
 
 
 @overload
-def ask_question(question: str, expected_type: LitInt, default: OptInt = None, **kwargs) -> int: ...
+def ask_question(question: str, expected_type: type[bool], default: OptBool = None) -> bool: ...
 
 
 @overload
-def ask_question(question: str, expected_type: LitFloat, default: OptFloat = None, **kwargs) -> float: ...
+def ask_question(question: str, expected_type: type[int], default: OptInt = None) -> int: ...
 
 
 @overload
-def ask_question(question: str, expected_type: LitStr, default: OptStr = None, **kwargs) -> str: ...
+def ask_question(question: str, expected_type: type[float], default: OptFloat = None) -> float: ...
 
 
 @overload
-def ask_question(question: str, expected_type: LitBool, default: OptBool = None, **kwargs) -> bool: ...
+def ask_question(question: str, expected_type: type[str], default: OptStr = None) -> str: ...
 
 
-def ask_question(question: str, expected_type: Any, default: Any = None, **_) -> Any:
-    """Ask a question and return the answer, ensuring the entered type is correct and a value is entered.
+def ask_question(question: str, expected_type: type, default: Any = None) -> Any:
+    """Ask a question and return the answer, ensuring the entered type is correct.
 
     This function will keep asking until it gets a valid response or the user cancels with Ctrl+C.
     If the user cancels, a UserCancelledError is raised.
 
     Args:
         question: The prompt question to display
-        expected_type: The expected type of the answer (int, float, str, bool)
+        expected_type: The expected type class (int, float, str, bool)
         default: Default value if no input is provided
 
     Returns:
@@ -48,46 +71,29 @@ def ask_question(question: str, expected_type: Any, default: Any = None, **_) ->
         ValueError: If an unsupported type is specified
     """
     console, sub = get_console("prompt_helpers.py")
+
     try:
         while True:
             console.print(question)
-            response: str = prompt("> ")
-            if response == "":
+            response = prompt("> ").strip()
+
+            if not response:
                 if default is not None:
                     return default
+                sub.error("Input required. Please enter a value.")
                 continue
-            match expected_type:
-                case "int":
-                    try:
-                        result = int(response)
-                        sub.verbose("int detected")
-                        return result
-                    except ValueError:
-                        sub.error("Invalid input. Please enter a valid integer.")
-                case "float":
-                    try:
-                        result = float(response)
-                        sub.verbose("float detected")
-                        return result
-                    except ValueError:
-                        sub.error("Invalid input. Please enter a valid float.")
-                case "str":
-                    sub.verbose("str detected")
-                    return response
-                case "bool":
-                    lower_response = response.lower()
-                    if lower_response in ("true", "t", "yes", "y", "1"):
-                        return True
-                    if lower_response in ("false", "f", "no", "n", "0"):
-                        return False
-                    sub.error("Invalid input. Please enter a valid boolean (true/false, yes/no, etc).")
-                case _:
-                    raise ValueError(f"Unsupported type: {expected_type}")
+            try:
+                result: str | int | float | bool = _convert_value(response, expected_type)
+                sub.verbose(f"{expected_type.__name__} detected")
+                return result
+            except ValueError as e:
+                sub.error(f"Invalid input: {e}. Please enter a valid {expected_type.__name__}.")
+
     except KeyboardInterrupt:
         raise UserCancelledError("User cancelled input") from None
 
 
-def ask_yes_no(question: str, default: None | Any = None, **kwargs) -> None | bool:
+def ask_yes_no(question: str, default: bool | None = None) -> bool | None:
     """Ask a yes or no question and return the answer.
 
     Args:
@@ -95,78 +101,85 @@ def ask_yes_no(question: str, default: None | Any = None, **kwargs) -> None | bo
         default: Default value if no input is provided
 
     Returns:
-        True for yes, False for no, or None if no valid response is given
+        True for yes, False for no, or None if user exits
     """
-    kwargs = kwargs or {}
-    sub, console = get_console("prompt_helpers.py")
+    console, sub = get_console("prompt_helpers.py")
+
     try:
         while True:
-            console.info(question)
-            response = prompt("> ")
+            console.print(question)
+            response = prompt("> ").strip().lower()
 
-            if response == "":
+            if not response:
                 if default is not None:
                     return default
+                sub.error("Please enter 'yes', 'no', or 'exit'.")
                 continue
 
-            if response.lower() in ["yes", "y"]:
-                return True
-            if response.lower() in ["no", "n"]:
-                return False
-            if response.lower() in ["exit", "quit"]:
+            if response in ("exit", "quit"):
                 return None
-            console.error("Invalid input. Please enter 'yes' or 'no' or exit.")
-            continue
+            try:
+                return _parse_bool(response)
+            except ValueError:
+                sub.error("Invalid input. Please enter 'yes', 'no', or 'exit'.")
     except KeyboardInterrupt:
-        console.warning("KeyboardInterrupt: Exiting the prompt.")
+        sub.warning("KeyboardInterrupt: Exiting the prompt.")
         return None
 
 
-def restricted_prompt(question: str, valid_options: list[str], exit_command: str = "exit", **kwargs) -> None | str:
+def restricted_prompt(
+    question: str, valid_options: list[str], exit_command: str = "exit", case_sensitive: bool = False
+) -> str | None:
     """Continuously prompt the user until they provide a valid response or exit.
 
     Args:
         question: The prompt question to display
         valid_options: List of valid responses
         exit_command: Command to exit the prompt (default: "exit")
+        case_sensitive: Whether options are case-sensitive (default: False)
 
     Returns:
         The user's response or None if they chose to exit
     """
-    kwargs = kwargs or {}
-    sub, console = get_console("prompt_helpers.py")
-    completer_options: list[str] = [*valid_options, exit_command]
+    console, sub = get_console("prompt_helpers.py")
+    completer_options = [*valid_options, exit_command]
     completer = WordCompleter(completer_options)
 
+    comparison_options = valid_options if case_sensitive else [opt.lower() for opt in valid_options]
+    comparison_exit = exit_command if case_sensitive else exit_command.lower()
+
     class OptionValidator(Validator):
         def validate(self, document: Any) -> None:
             """Validate the user's input against the valid options."""
-            text: str = document.text.lower()
-            if text != exit_command and text not in valid_options:
+            text: Any = document.text if case_sensitive else document.text.lower()
+            if text and text != comparison_exit and text not in comparison_options:
                 raise ValidationError(
-                    message=f"Invalid option: {text}. Please choose from {', '.join(valid_options)} or type '{exit_command}' to exit.",
+                    message=f"Invalid option. Choose from: {', '.join(valid_options)} or '{exit_command}'",
                     cursor_position=len(document.text),
                 )
 
     try:
         while True:
-            if console is not None:
-                console.info(question)
-                response = prompt("> ", completer=completer, validator=OptionValidator(), complete_while_typing=True)
-                response = response.lower()
-            else:
-                response = prompt(
-                    question, completer=completer, validator=OptionValidator(), complete_while_typing=True
-                )
-                response = response.lower()
-
-            if response == exit_command:
-                return None
-            if response == "":
-                sub.error("No input provided. Please enter a valid option or exit.")
+            console.print(question)
+            response: str = prompt(
+                "> ", completer=completer, validator=OptionValidator(), complete_while_typing=True
+            ).strip()
+            comparison_response: str = response if case_sensitive else response.lower()
+            if not response:
+                sub.error("Please enter a valid option or 'exit'.")
                 continue
-            if response in valid_options:
+            if comparison_response == comparison_exit:
+                return None
+            if comparison_response in comparison_options:
+                if not case_sensitive:
+                    idx: int = comparison_options.index(comparison_response)
+                    return valid_options[idx]
                 return response
+
     except KeyboardInterrupt:
         sub.warning("KeyboardInterrupt: Exiting the prompt.")
         return None
+
+
+if __name__ == "__main__":
+    ask_question("What is your age?", int)

bear_utils/extras/responses/function_response.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from io import StringIO
+from collections.abc import Callable
 import json
 from subprocess import CompletedProcess
+from types import SimpleNamespace as Namespace
 from typing import Any, Literal, Self, overload
 
 from pydantic import BaseModel, Field, field_validator
@@ -23,35 +24,46 @@ class FunctionResponse(BaseModel):
     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")
+    sub_tasks: list[FunctionResponse] = Field(default_factory=list, description="List of sub-tasks.")
     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.")
+    attrs: Namespace = Field(default_factory=Namespace, description="Storing additional attributes dynamically.")
 
     model_config = {
         "arbitrary_types_allowed": True,
     }
 
+    def __getattr__(self, key: str, default: Any = None) -> Any:
+        if key in FunctionResponse.model_fields:
+            raise AttributeError(f"This should never be called, {key} is a model field.")
+        if hasattr(self.attrs, key):
+            return getattr(self.attrs, key)
+        return default
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        if key in FunctionResponse.model_fields:
+            object.__setattr__(self, key, value)
+            return
+        setattr(self.attrs, key, value)
+
     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
+        parts: list[str] = []
+
+        def add(k: str, v: Any, _bool: bool = True, formatter: Callable | None = None) -> None:
+            if _bool:
+                formatted_value: str = formatter(v) if formatter else repr(v)
+                parts.append(f"{k}={formatted_value}")
+
+        add("name", self.name, bool(self.name))
+        add("returncode", self.returncode, self.returncode != 0)
+        add("success", self.success, bool(self.returncode))
+        add("content", ", ".join(self.content), bool(self.content))
+        add("error", ", ".join(self.error), bool(self.error))
+        add("extra", self.extra, bool(self.extra), json.dumps)
+        add("number_of_tasks", self.number_of_tasks, self.number_of_tasks > 0)
+
+        return f"Response({', '.join(parts)})"
 
     def __str__(self) -> str:
         """Return a string representation of Response."""
@@ -124,6 +136,19 @@ class FunctionResponse(BaseModel):
 
         return cls().add(returncode=returncode, content=content, error=error, **kwargs)
 
+    def from_response(self, response: FunctionResponse | Any, **kwargs) -> Self:
+        """Create a FunctionResponse from another FunctionResponse object."""
+        if not isinstance(response, FunctionResponse):
+            raise TypeError("Expected a FunctionResponse instance.")
+        self.sub_tasks.append(response)
+        return self.add(
+            content=response.content,
+            error=response.error,
+            returncode=response.returncode,
+            log_output=kwargs.pop("log_output", False),
+            **kwargs,
+        )
+
     @property
     def success(self) -> bool:
         """Check if the response indicates success."""
@@ -137,7 +162,7 @@ class FunctionResponse(BaseModel):
         extra: dict[str, Any] | None = None,
         returncode: int | None = None,
         log_output: bool = False,
-    ) -> None:
+    ) -> Self:
         """Add a sub-task response to the FunctionResponse."""
         func_response: FunctionResponse = FunctionResponse(name=name, logger=self.logger).add(
             content=content,
@@ -147,6 +172,8 @@ class FunctionResponse(BaseModel):
             extra=extra,
         )
         self.add(content=func_response)
+        self.sub_tasks.append(func_response)
+        return self
 
     def successful(
         self,
@@ -170,49 +197,41 @@ class FunctionResponse(BaseModel):
         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_item(self, item: str, target_list: list[str]) -> None:
+        """Append an item to the target list if not empty."""
+        if item != "":
+            target_list.append(item)
 
-    def _add_to_error(self, error: str | list[str], name: str | None = None) -> None:
-        """Append additional error messages to the existing error."""
+    def _add_to_list(self, items: str | list[str], target_list: list[str], name: str | None = None) -> None:
+        """Append items to the target list with optional name prefix."""
         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)
+            if isinstance(items, list):
+                for item in items:
+                    self._add_item(f"{name}: {item}" if name else item, target_list)
+            elif isinstance(items, str):
+                self._add_item(f"{name}: {items}" if name else items, target_list)
         except Exception as e:
-            raise ValueError(f"Failed to add error: {e!s}") from e
+            raise ValueError(f"Failed to add items: {e!s}") from e
 
-    def _add_content(self, content: str) -> None:
+    def _add_content(self, content: str | list[str], name: str | None = None) -> None:
         """Append content to the existing content."""
-        if content != "":
-            self.content.append(content)
+        self._add_to_list(content, self.content, name)
 
-    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_error(self, error: str | list[str], name: str | None = None) -> None:
+        """Append error to the existing error."""
+        self._add_to_list(error, self.error, name)
 
     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)
+        self._add_error(error=func_response.error, name=func_response.name)
+        self._add_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._add_content(content=result.stdout.strip() if result.stdout else "")
+        self._add_error(error=result.stderr.strip() if result.stderr else "")
         self.returncode = result.returncode
 
     def add(
@@ -244,13 +263,13 @@ class FunctionResponse(BaseModel):
                     self._handle_completed_process(result=content)
                     self.number_of_tasks += 1
                 case str() | list() if content:
-                    self._add_to_content(content=content)
+                    self._add_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._add_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):
@@ -266,18 +285,19 @@ class FunctionResponse(BaseModel):
         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(f"{self.name}: {item}" if self.name else item)
-            elif isinstance(content, str):
-                logger.info(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(f"{self.name}: {err}" if self.name else err)
-            elif isinstance(error, str):
-                logger.error(f"{self.name}: {error}" if self.name else error)
+
+        def _log_messages(messages: str | list[str], log_func: Callable) -> None:
+            if isinstance(messages, str):
+                messages = [messages]
+            if isinstance(messages, list):
+                for msg in messages:
+                    log_func(f"{self.name}: {msg}" if self.name else msg)
+
+        if content and isinstance(content, (str | list)):
+            _log_messages(content, logger.info)
+
+        if error and isinstance(error, (str | list)):
+            _log_messages(error, logger.error)
 
     @overload
     def done(self, to_dict: Literal[True], suppress: list[str] | None = None) -> dict[str, Any]: ...
@@ -295,26 +315,26 @@ class FunctionResponse(BaseModel):
         Returns:
             dict[str, Any] | Self: The dictionary representation or the FunctionResponse instance.
         """
+        if not to_dict:
+            return self
+
         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
+
+        result: dict[str, Any] = {}
+
+        def add(k: str, v: Any, _bool: bool = True) -> None:
+            if k not in suppress and _bool:
+                result[k] = v
+
+        add("name", self.name, bool(self.name))
+        add("success", self.success)
+        add("returncode", self.returncode, self.returncode > 0)
+        add("number_of_tasks", self.number_of_tasks, self.number_of_tasks > 0)
+        add("content", self.content, bool(self.content))
+        add("error", self.error, bool(self.error))
+        result.update(self.extra)
+        return result
 
 
 def success(
@@ -334,3 +354,16 @@ def fail(
 ) -> FunctionResponse:
     """Create a failed FunctionResponse."""
     return FunctionResponse().fail(content=content, error=error, returncode=returncode, **kwargs)
+
+
+if __name__ == "__main__":
+    # Example usage
+    from rich import inspect
+
+    response = FunctionResponse(name="example_function", returncode=0, content=["Task completed successfully."])
+    response.task_id = 124
+
+    inspect(response)
+    print(response)
+    print(response.done(to_dict=True))
+    print(response.done(to_dict=False))

{bear_utils-0.8.6.dist-info → bear_utils-0.8.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.8.6
+Version: 0.8.7
 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.8.6
+# Bear Utils v# Bear Utils v0.8.7
 
 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.8.6.dist-info → bear_utils-0.8.7.dist-info}/RECORD

@@ -12,7 +12,7 @@ bear_utils/ai/ai_helpers/_types.py,sha256=rmnl8mTlUj0LyL9USzTb-EN_31TtXY6qzhkOEu
 bear_utils/cache/__init__.py,sha256=c9z1mLhWpZJHZdXRlviYQXl8tc9KTJCM8vin3moDO3I,4578
 bear_utils/cli/__init__.py,sha256=H2QpLyHpQS_Yn3sF2px7n4KqT97LEe7Oyzafg2iHcpc,503
 bear_utils/cli/commands.py,sha256=5ppEjvVV_g28WLaIFtKgz-ctzwoo-g-KpHTXNx9xBzo,3161
-bear_utils/cli/prompt_helpers.py,sha256=DVdg1f5yZElVyFNao6RTPfrc6mKy4PoXLgY6az-ejo8,6580
+bear_utils/cli/prompt_helpers.py,sha256=8NmZcfnXteN-MhdE7sdH9iIu_xLi5bxArMWxX4vVWGU,6607
 bear_utils/cli/shell/__init__.py,sha256=2s3oR6CqLKj1iyERy7YafWT3t3KzTr70Z1yaLKa6IiQ,42
 bear_utils/cli/shell/_base_command.py,sha256=T1bwY9UX355Mv2u7JjSgI4U7VoWCTibszG8WvC3IEo4,2789
 bear_utils/cli/shell/_base_shell.py,sha256=GW2kgj_KR33FtJLvV-ljSs_wzo5WQ8--H-K2hDPOblQ,16697
@@ -37,7 +37,7 @@ bear_utils/extras/_async_helpers.py,sha256=cxq5d24NHkECmZqTVXEazv6K-XUa7skFnX6KQ
 bear_utils/extras/_tools.py,sha256=kxJ1jaqx3PvLpc0CZUIV8XQUwjQGrNCRLoka11aNtoc,7672
 bear_utils/extras/platform_utils.py,sha256=Ai7ow7S-_cKb5zFwFh8dkC8xmbMJFy-0_-w3NCERdEw,1362
 bear_utils/extras/responses/__init__.py,sha256=XbE4VKemrKRwx9E5jqy__OiM_AAjA58ebnqQ2hytnT0,225
-bear_utils/extras/responses/function_response.py,sha256=D6123VaOaJeeSQ9Gp1gtrvCSv7HF5Iw7dZlGbxHVQDk,14121
+bear_utils/extras/responses/function_response.py,sha256=7MSA9UvoBwWkbjhYvn63oEyQD3p2QCQNCOihgqbU6vQ,15185
 bear_utils/extras/wrappers/__init__.py,sha256=crh4sKOLvuhNMVX5bJYjCFWtXtH7G47UgNPOHq3HXTk,43
 bear_utils/extras/wrappers/add_methods.py,sha256=z2XZG2ZoYOB1MaGiLli4NRyyTeRgBy7tuYsiy8mTa9s,4422
 bear_utils/files/__init__.py,sha256=mIdnFSXoDE64ElM43bN2m6KuafURnN82ki0pdqN8q2o,201
@@ -80,6 +80,6 @@ bear_utils/monitoring/__init__.py,sha256=9DKNIWTp_voLnaWgiP-wJ-o_N0hYixo-MzjUmg8
 bear_utils/monitoring/_common.py,sha256=LYQFxgTP9fk0cH71IQTuGwBYYPWCqHP_mMRNecoD76M,657
 bear_utils/monitoring/host_monitor.py,sha256=e0TYRJw9iDj5Ga6y3ck1TBFEeH42Cax5mQYaNU8yams,13241
 bear_utils/time/__init__.py,sha256=d9Ovv-Dlx5NWgnOl1hY-evznVm9hboS6ypNp1wDFxQQ,934
-bear_utils-0.8.6.dist-info/METADATA,sha256=QG8sOkLV4XiFr490DziS-jSq9tIaICPgMvz--TgyaZI,8634
-bear_utils-0.8.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bear_utils-0.8.6.dist-info/RECORD,,
+bear_utils-0.8.7.dist-info/METADATA,sha256=RvbYBZNY_8VnUBwYqsR44LHhmPJJ9_-9K3hlVd4rNuk,8634
+bear_utils-0.8.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bear_utils-0.8.7.dist-info/RECORD,,