bear-utils 0.8.21__tar.gz → 0.8.23__tar.gz

{bear_utils-0.8.21 → bear_utils-0.8.23}/.bumpversion.cfg

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

{bear_utils-0.8.21 → bear_utils-0.8.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.8.21
+Version: 0.8.23
 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
@@ -24,7 +24,7 @@ Provides-Extra: gui
 Requires-Dist: pyqt6>=6.9.0; extra == 'gui'
 Description-Content-Type: text/markdown
 
-# Bear Utils v# Bear Utils v0.8.21
+# Bear Utils v# Bear Utils v0.8.23
 
 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.21 → bear_utils-0.8.23}/README.md

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.8.21
+# Bear Utils v# Bear Utils v0.8.23
 
 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.21 → bear_utils-0.8.23}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.8.21"
+version = "0.8.23"
 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"

{bear_utils-0.8.21 → bear_utils-0.8.23}/src/bear_utils/database/_db_manager.py

@@ -32,42 +32,35 @@ class DatabaseManager:
             raise ValueError("Base class is not set, failed to set base.")
         return cls._base
 
-    def __init__(self, db_url: str | Path | None = None):
+    def __init__(self, db_url: str | Path | None = None, default_schema: str = "sqlite:///"):
         if db_url is None or db_url == "":
             raise ValueError("Database URL cannot be None or empty.")
-        if isinstance(db_url, str) and not db_url.startswith("sqlite://"):
-            db_url = f"sqlite:///{db_url}"
+        if isinstance(db_url, str) and not db_url.startswith(default_schema):
+            db_url = f"{default_schema}{db_url}"
         self.db_url: str = str(db_url)
         self.engine: Engine = create_engine(self.db_url, echo=False)
         base: DeclarativeMeta = DatabaseManager.get_base()
         self.metadata: MetaData = base.metadata
-        self.SessionFactory = sessionmaker(bind=self.engine)
-        self.session = scoped_session(self.SessionFactory)
+        self.SessionFactory: sessionmaker[Session] = sessionmaker(bind=self.engine)
+        self.session: scoped_session[Session] = scoped_session(self.SessionFactory)
         atexit.register(self.close_all)
         self.create_tables()
 
     def get_all_records(self, table_obj: type[TableType]) -> list[TableType]:
         """Get all records from a table."""
-        with self.open_session() as session:
-            return session.query(table_obj).all()
+        return self.session().query(table_obj).all()
 
     def count_records(self, table_obj: type[TableType]) -> int:
         """Count the number of records in a table."""
-        with self.open_session() as session:
-            count: int = session.query(table_obj).count()
-        return count
+        return self.session().query(table_obj).count()
 
     def get_records_by_var(self, table_obj: type[TableType], variable: str, value: str) -> list[TableType]:
         """Get records from a table by a specific variable."""
-        with self.open_session() as session:
-            records: list[TableType] = session.query(table_obj).filter(getattr(table_obj, variable) == value).all()
-        return records
+        return self.session().query(table_obj).filter(getattr(table_obj, variable) == value).all()
 
     def count_records_by_var(self, table_obj: type[TableType], variable: str, value: str) -> int:
         """Count the number of records in a table by a specific variable."""
-        with self.open_session() as session:
-            count: int = session.query(table_obj).filter(getattr(table_obj, variable) == value).count()
-        return count
+        return self.session().query(table_obj).filter(getattr(table_obj, variable) == value).count()
 
     @contextmanager
     def open_session(self) -> Generator[Session, Any]:

bear_utils-0.8.23/src/bear_utils/extras/_async_helpers.py

@@ -0,0 +1,67 @@
+import asyncio
+from asyncio import AbstractEventLoop, Task
+from collections.abc import Callable
+from contextlib import suppress
+import inspect
+
+from pydantic import BaseModel, Field
+
+
+class AsyncResponseModel(BaseModel):
+    """A model to handle asynchronous operations with a function and its arguments."""
+
+    loop: AbstractEventLoop | None = Field(default=None, description="The event loop to run the function in.")
+    task: Task | None = Field(default=None, description="The task created for the asynchronous function.")
+    before_loop: bool = Field(default=False, description="If the function was called from a running loop.")
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    def conditional_run(self) -> None:
+        """Run the event loop until the task is complete if not in a running loop."""
+        if self.loop and self.task and not self.before_loop:
+            self.loop.run_until_complete(self.task)
+
+
+def is_async_function(func: Callable) -> bool:
+    """Check if a function is asynchronous.
+
+    Args:
+        func (Callable): The function/method to check.
+
+    Returns:
+        bool: True if the function is asynchronous, False otherwise.
+    """
+    return inspect.iscoroutinefunction(func) or inspect.isasyncgenfunction(func) or inspect.isasyncgen(func)
+
+
+def in_async_loop() -> bool:
+    """Check if the current context is already in an async loop.
+
+    Returns:
+        bool: True if an async loop is running, False otherwise.
+    """
+    loop: AbstractEventLoop | None = None
+    with suppress(RuntimeError):
+        loop = asyncio.get_running_loop()
+    return loop.is_running() if loop else False
+
+
+def gimmie_async_loop() -> AbstractEventLoop:
+    """Get the current event loop, creating one if it doesn't exist."""
+    if in_async_loop():
+        return asyncio.get_event_loop()
+    loop: AbstractEventLoop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    return loop
+
+
+def create_async_task(
+    func: Callable,
+    *args,
+    **kwargs,
+) -> AsyncResponseModel:
+    """Create an asyncio task for a given function."""
+    before_loop: bool = in_async_loop()
+    loop: AbstractEventLoop = gimmie_async_loop()
+    task = loop.create_task(func(*args, **kwargs))
+    return AsyncResponseModel(loop=loop, task=task, before_loop=before_loop)

{bear_utils-0.8.21 → bear_utils-0.8.23}/src/bear_utils/extras/responses/function_response.py

@@ -2,22 +2,24 @@
 
 from __future__ import annotations
 
-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 typing import TYPE_CHECKING, Any, Literal, Self, overload
 
 from pydantic import BaseModel, Field, field_validator
 
-from bear_utils.extras._async_helpers import AbstractEventLoop, gimmie_async_loop, in_async_loop, is_async_function
-from bear_utils.logger_manager import (
-    AsyncLoggerProtocol,
-    LoggerProtocol,
-)
+from bear_utils.extras._async_helpers import AsyncResponseModel, create_async_task, is_async_function
 
-SUCCESS: list[str] = ["name", "success"]
-FAILURE: list[str] = ["name"]
+# Pydantic will yell if we put this into a TYPE_CHECKING block.
+from bear_utils.logger_manager import AsyncLoggerProtocol, LoggerProtocol  # noqa: TC001
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+SUCCESS: list[str] = ["name", "success", "number_of_tasks"]
+FAILURE: list[str] = ["name", "number_of_tasks"]
 
 
 class FunctionResponse(BaseModel):
@@ -240,6 +242,19 @@ class FunctionResponse(BaseModel):
         self._add_error(error=result.stderr.strip() if result.stderr else "")
         self.returncode = result.returncode
 
+    def _handle_content(self, content: list[str] | str | FunctionResponse | CompletedProcess | Any) -> None:
+        """Handle different types of content and update the FunctionResponse."""
+        if isinstance(content, FunctionResponse):
+            self._handle_function_response(func_response=content)
+        elif isinstance(content, CompletedProcess):
+            self._handle_completed_process(result=content)
+        elif isinstance(content, (str | list)):
+            self._add_content(content=content)
+        else:
+            return
+        self.number_of_tasks += 1
+
+    @overload
     def add(
         self,
         content: list[str] | str | FunctionResponse | CompletedProcess | None = None,
@@ -247,19 +262,36 @@ class FunctionResponse(BaseModel):
         returncode: int | None = None,
         log_output: bool = False,
         extra: dict[str, Any] | None = None,
-    ) -> Self:
+        *,
+        to_dict: Literal[True],
+    ) -> dict[str, Any]: ...
+
+    @overload
+    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,
+        *,
+        to_dict: Literal[False] = False,
+    ) -> Self: ...
+
+    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,
+        *,
+        to_dict: bool = False,
+    ) -> Self | dict[str, Any]:
         """Append additional content to the existing content."""
         try:
             if content is not None:
-                if isinstance(content, FunctionResponse):
-                    self._handle_function_response(func_response=content)
-                    self.number_of_tasks += 1
-                elif isinstance(content, CompletedProcess):
-                    self._handle_completed_process(result=content)
-                    self.number_of_tasks += 1
-                elif isinstance(content, (str | list)) and content:
-                    self._add_content(content=content)
-                    self.number_of_tasks += 1
+                self._handle_content(content=content)
             if error is not None and isinstance(error, (str | list)):
                 self._add_error(error=error)
             if isinstance(returncode, int):
@@ -270,6 +302,8 @@ class FunctionResponse(BaseModel):
                 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
+        if to_dict:
+            return self.done(to_dict=True)
         return self
 
     def _log_handling(
@@ -304,22 +338,16 @@ class FunctionResponse(BaseModel):
             content = []
         if not isinstance(error, (list | str)):
             error = []
-
         if not content and not error:
             return
-
-        before_loop: bool = in_async_loop()
-        loop: AbstractEventLoop = gimmie_async_loop()
-        task = loop.create_task(
-            _log_messages(
-                content=content,
-                error=error,
-                info_func=logger.info,
-                error_func=logger.error,
-            )
+        res: AsyncResponseModel = create_async_task(
+            _log_messages,
+            content=content,
+            error=error,
+            info_func=logger.info,
+            error_func=logger.error,
         )
-        if task is not None and loop is not None and not before_loop:
-            loop.run_until_complete(task)
+        res.conditional_run()
 
     @overload
     def done(self, to_dict: Literal[True], suppress: list[str] | None = None) -> dict[str, Any]: ...
@@ -352,7 +380,7 @@ class FunctionResponse(BaseModel):
         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("number_of_tasks", self.number_of_tasks, (self.number_of_tasks > 0 and not self.success))
         add("content", self.content, bool(self.content))
         add("error", self.error, bool(self.error))
         result.update(self.extra)

{bear_utils-0.8.21 → bear_utils-0.8.23}/src/bear_utils/gui/gui_tools/qt_app.py

@@ -36,7 +36,7 @@ class QTApplication(QObject):
                 self.app.setOrganizationDomain(org_domain)
         else:
             self.app = QApplication.instance()
-        self.console = ConsoleLogger.get_instance(init=True, name=app_name, level=VERBOSE)
+        self.console: ConsoleLogger = ConsoleLogger.get_instance(init=True, name=app_name, level=VERBOSE)
         atexit.register(self.cleanup)
 
     def _default_exit_shortcuts(self) -> None:

{bear_utils-0.8.21 → bear_utils-0.8.23}/tests/test_function_response.py

@@ -635,15 +635,30 @@ class TestComplexScenarios:
         response.successful("Cleared 5 completed tasks")
         response.add(content="Operation summary generated")
 
-        # Get dict format suitable for MCP
         result = response.done(to_dict=True, suppress=SUCCESS)
 
         # SUCCESS suppresses "name" and "success", so check what actually remains
         assert "content" in result
-        assert "number_of_tasks" in result
+        assert "number_of_tasks" not in result  # This will only be here in failures
         assert "name" not in result
         assert "success" not in result
 
+    def test_mcp_server_response_format_error(self):
+        """Test formatting response for MCP server consumption."""
+        response = FunctionResponse(name="clear_tasks_error")
+
+        # Add some successful operations
+        response.fail("Failed to clear tasks")
+        response.add(content="Error summary generated")
+
+        result = response.done(to_dict=True, suppress=FAILURE)
+
+        # SUCCESS suppresses "name" and "success", so check what actually remains
+        assert "content" in result
+        assert "number_of_tasks" in result
+        assert "name" not in result
+        assert "success" in result
+
     def test_error_handling_in_add_method(self):
         """Test error handling within add method."""
         response = FunctionResponse()

bear_utils-0.8.21/src/bear_utils/extras/_async_helpers.py

@@ -1,38 +0,0 @@
-import asyncio
-from asyncio import AbstractEventLoop
-from collections.abc import Callable
-from contextlib import suppress
-import inspect
-
-
-def is_async_function(func: Callable) -> bool:
-    """Check if a function is asynchronous.
-
-    Args:
-        func (Callable): The function/method to check.
-
-    Returns:
-        bool: True if the function is asynchronous, False otherwise.
-    """
-    return inspect.iscoroutinefunction(func) or inspect.isasyncgenfunction(func) or inspect.isasyncgen(func)
-
-
-def in_async_loop() -> bool:
-    """Check if the current context is already in an async loop.
-
-    Returns:
-        bool: True if an async loop is running, False otherwise.
-    """
-    loop: AbstractEventLoop | None = None
-    with suppress(RuntimeError):
-        loop = asyncio.get_running_loop()
-    return loop.is_running() if loop else False
-
-
-def gimmie_async_loop() -> AbstractEventLoop:
-    """Get the current event loop, creating one if it doesn't exist."""
-    if in_async_loop():
-        return asyncio.get_event_loop()
-    loop: AbstractEventLoop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    return loop