bear-utils 0.7.14__tar.gz → 0.7.15__tar.gz

bear_utils-0.7.15/.bumpversion.cfg

@@ -0,0 +1,8 @@
+[bumpversion]
+current_version = 0.7.15
+
+[bumpversion:file:pyproject.toml]
+
+[bumpversion:file:README.md]
+search = # Bear Utils v{current_version}
+replace = # Bear Utils v{new_version}

bear_utils-0.7.15/.gitignore

@@ -0,0 +1,165 @@
+# ---- Python ----
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+**/.vscode

bear_utils-0.7.15/.python-version

@@ -0,0 +1 @@
+3.13.3

bear_utils-0.7.15/AGENTS.md

@@ -0,0 +1,11 @@
+# Contributor Guide for AI Agents
+
+## Dev Environment Guidelines
+
+- Python Version and Typing: Assume Python 3.12 or higher is being used. Because of that we SHOULD use the latest typing features available in Python 3.12 and later. Never use `Optional`, `Union`, or `Dict, List, Tuple` from `typing` module. Instead, use the built-in types directly, e.g., `list`, `dict`, `tuple`, and use `|` for union types. This is not an exhaustive list, so be thoughtful about any potentially deprecated types you might use. If you are not sure about something, ask the user.
+- Type Annotations: Use type annotations as often as possible. If a function has no return value, use `None` as the return type. If a function returns a value, use the appropriate type annotation but don't bend over backwards to make it perfect. If you are not sure about the type, use `Any` as a fallback but use this sparingly, see it as a failure and you should endeavor to avoid using `Any` as much as possible.
+- Docstrings: Use docstrings for most (95%) public functions and classes. The docstring should describe the purpose of the function or class, its parameters, and its return value. Use the Google style for docstrings. Because of this it is highly preferred to not use comments in the code unless absolutely necessary. If you feel like you need to use a comment, consider if the code can be refactored to make it more readable instead.
+- Imports: Use relative imports for everything (beyond the obvious imports for external packages) in this current package. Keep imports clean using `isort src tests` and `black src tests -l 120` to format the code in that order.
+- Endeavor to use a TDD approach when writing new code. Write tests first, then write the code to make the tests pass and then refactor the code to make it cleaner and more readable.
+- There is a `directory_structure.txt` file in the root of the repository that describes the directory structure of the project. Use this as a quick way to understand the project structure and where to place new files or modules.
+- While projects might partially use Poetry, UV is generally the preferred tool for managing dependencies and virtual environments. It is taking me some time to get used to it, so please bear with me. If you are not sure about something, ask the user. If a dependency is not available, then you will need to request the user to add it to the `pyproject.toml` file.

{bear_utils-0.7.14 → bear_utils-0.7.15}/PKG-INFO

@@ -1,29 +1,25 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.7.14
+Version: 0.7.15
 Summary: Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things.
-Author: chaz
-Author-email: bright.lid5647@fastmail.com
+Author-email: chaz <bright.lid5647@fastmail.com>
 Requires-Python: >=3.12
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: bear-epoch-time (>=1.0.1)
-Requires-Dist: diskcache (>=5.6.3,<6.0.0)
-Requires-Dist: httpx (>=0.28.1)
-Requires-Dist: pathspec (>=0.12.1)
-Requires-Dist: pillow (>=11.2.1,<12.0.0)
-Requires-Dist: prompt-toolkit (>=3.0.51,<4.0.0)
-Requires-Dist: pydantic (>=2.11.5)
-Requires-Dist: pyglm (>=2.8.2,<3.0.0)
-Requires-Dist: pyqt6 (>=6.9.0)
-Requires-Dist: pyyaml (>=6.0.2)
-Requires-Dist: rich (>=14.0.0,<15.0.0)
-Requires-Dist: singleton-base (>=1.0.5)
-Requires-Dist: sqlalchemy (>=2.0.40,<3.0.0)
+Requires-Dist: bear-epoch-time>=1.0.1
+Requires-Dist: diskcache<6.0.0,>=5.6.3
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pathspec>=0.12.1
+Requires-Dist: pillow<12.0.0,>=11.2.1
+Requires-Dist: prompt-toolkit<4.0.0,>=3.0.51
+Requires-Dist: pydantic>=2.11.5
+Requires-Dist: pyglm<3.0.0,>=2.8.2
+Requires-Dist: pyqt6>=6.9.0
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: rich<15.0.0,>=14.0.0
+Requires-Dist: singleton-base>=1.0.5
+Requires-Dist: sqlalchemy<3.0.0,>=2.0.40
 Description-Content-Type: text/markdown
 
-# Bear Utils v# Bear Utils v0.7.14
+# Bear Utils v# Bear Utils v0.7.15
 
 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.
 
@@ -257,4 +253,3 @@ def handle_function(func):
         # Handle sync function
         pass
 ```
-

{bear_utils-0.7.14 → bear_utils-0.7.15}/README.md

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.7.14
+# Bear Utils v# Bear Utils v0.7.15
 
 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.15/directory_structure.txt

@@ -0,0 +1,118 @@
+📁  bear-utils
+├── ⚙️ .bumpversion.cfg (312 bytes) (12 lines)
+├── 🗃️ .gitignore (3170 bytes) (165 lines)
+├── 🐍 .python-version (7 bytes) (1 lines)
+├── 📄 AGENTS.md (2953 bytes) (12 lines)
+├── 📄 directory_structure.txt (7154 bytes) (118 lines)
+├── 📄 pyproject.toml (970 bytes) (41 lines)
+├── 📄 README.md (5267 bytes) (208 lines)
+├── 📁 src
+│   └── 📁 bear_utils
+│       ├── 🐍 __init__.py (616 bytes) (13 lines)
+│       ├── 📁 ai
+│       │   ├── 🐍 __init__.py (26 bytes) (1 lines)
+│       │   └── 📁 ai_helpers
+│       │       ├── 🐍 __init__.py (3968 bytes) (130 lines)
+│       │       ├── 🐍 _common.py (418 bytes) (19 lines)
+│       │       ├── 🐍 _config.py (789 bytes) (25 lines)
+│       │       ├── 🐍 _parsers.py (7993 bytes) (188 lines)
+│       │       └── 🐍 _types.py (550 bytes) (20 lines)
+│       ├── 📁 cache
+│       │   └── 🐍 __init__.py (4101 bytes) (119 lines)
+│       ├── 📁 cli
+│       │   ├── 🐍 __init__.py (241 bytes) (4 lines)
+│       │   ├── 🐍 commands.py (1768 bytes) (65 lines)
+│       │   ├── 🐍 prompt_helpers.py (6094 bytes) (166 lines)
+│       │   └── 📁 shell
+│       │       ├── 🐍 __init__.py (0 bytes) (0 lines)
+│       │       ├── 🐍 _base_command.py (2251 bytes) (74 lines)
+│       │       ├── 🐍 _base_shell.py (14596 bytes) (390 lines)
+│       │       └── 🐍 _common.py (669 bytes) (19 lines)
+│       ├── 📁 config
+│       │   ├── 🐍 __init__.py (289 bytes) (11 lines)
+│       │   ├── 🐍 config_manager.py (2631 bytes) (92 lines)
+│       │   ├── 🐍 dir_manager.py (1865 bytes) (64 lines)
+│       │   └── 🐍 settings_manager.py (7484 bytes) (232 lines)
+│       ├── 📁 constants
+│       │   ├── 🐍 __init__.py (545 bytes) (16 lines)
+│       │   ├── 🐍 _exceptions.py (137 bytes) (3 lines)
+│       │   ├── 🐍 _lazy_typing.py (339 bytes) (15 lines)
+│       │   ├── 🐍 date_related.py (935 bytes) (27 lines)
+│       │   └── 🐍 time_related.py (638 bytes) (22 lines)
+│       ├── 🛢️ database
+│       │   ├── 🐍 __init__.py (111 bytes) (6 lines)
+│       │   └── 🐍 _db_manager.py (3782 bytes) (104 lines)
+│       ├── 📁 events
+│       │   ├── 🐍 __init__.py (364 bytes) (16 lines)
+│       │   ├── 🐍 events_class.py (1657 bytes) (52 lines)
+│       │   └── 🐍 events_module.py (1852 bytes) (65 lines)
+│       ├── 📁 extras
+│       │   ├── 🐍 __init__.py (484 bytes) (17 lines)
+│       │   ├── 🐍 _async_helpers.py (416 bytes) (15 lines)
+│       │   ├── 🐍 _tools.py (5959 bytes) (174 lines)
+│       │   ├── 🐍 platform_utils.py (1257 bytes) (53 lines)
+│       │   └── 📁 wrappers
+│       │       ├── 🐍 __init__.py (0 bytes) (0 lines)
+│       │       └── 🐍 add_methods.py (4222 bytes) (98 lines)
+│       ├── 📁 files
+│       │   ├── 🐍 __init__.py (142 bytes) (4 lines)
+│       │   ├── 🐍 ignore_parser.py (10678 bytes) (298 lines)
+│       │   └── 📁 file_handlers
+│       │       ├── 🐍 __init__.py (87 bytes) (3 lines)
+│       │       ├── 🐍 _base_file_handler.py (3164 bytes) (93 lines)
+│       │       ├── 🐍 file_handler_factory.py (9746 bytes) (278 lines)
+│       │       ├── 🐍 json_file_handler.py (1482 bytes) (44 lines)
+│       │       ├── 🐍 log_file_handler.py (1246 bytes) (33 lines)
+│       │       ├── 🐍 txt_file_handler.py (1250 bytes) (34 lines)
+│       │       └── 🐍 yaml_file_handler.py (2083 bytes) (57 lines)
+│       ├── 📁 graphics
+│       │   ├── 🐍 __init__.py (186 bytes) (4 lines)
+│       │   ├── 🐍 bear_gradient.py (4769 bytes) (140 lines)
+│       │   └── 🐍 image_helpers.py (1374 bytes) (39 lines)
+│       ├── 📁 gui
+│       │   ├── 🐍 __init__.py (118 bytes) (3 lines)
+│       │   └── 📁 gui_tools
+│       │       ├── 🐍 __init__.py (171 bytes) (5 lines)
+│       │       ├── 🐍 _settings.py (1202 bytes) (37 lines)
+│       │       ├── 🐍 _types.py (248 bytes) (12 lines)
+│       │       ├── 🐍 qt_app.py (5520 bytes) (145 lines)
+│       │       ├── 🐍 qt_color_picker.py (4437 bytes) (119 lines)
+│       │       ├── 🐍 qt_file_handler.py (4325 bytes) (138 lines)
+│       │       └── 🐍 qt_input_dialog.py (9224 bytes) (306 lines)
+│       ├── 📁 logging
+│       │   ├── 🐍 __init__.py (319 bytes) (12 lines)
+│       │   ├── 🐍 loggers.py (4507 bytes) (91 lines)
+│       │   └── 📁 logger_manager
+│       │       ├── 🐍 __init__.py (0 bytes) (0 lines)
+│       │       ├── 🐍 _common.py (1582 bytes) (47 lines)
+│       │       ├── 🐍 _console_junk.py (4821 bytes) (131 lines)
+│       │       ├── 🐍 _styles.py (2536 bytes) (91 lines)
+│       │       └── 📁 loggers
+│       │           ├── 🐍 __init__.py (0 bytes) (0 lines)
+│       │           ├── 🐍 _base_logger.py (9453 bytes) (238 lines)
+│       │           ├── 📄 _base_logger.pyi (2606 bytes) (50 lines)
+│       │           ├── 🐍 _console_logger.py (9126 bytes) (243 lines)
+│       │           ├── 📄 _console_logger.pyi (1470 bytes) (41 lines)
+│       │           ├── 🐍 _file_logger.py (5365 bytes) (150 lines)
+│       │           ├── 🐍 _level_sin.py (1712 bytes) (58 lines)
+│       │           ├── 🐍 _logger.py (547 bytes) (18 lines)
+│       │           ├── 🐍 _sub_logger.py (3471 bytes) (110 lines)
+│       │           └── 📄 _sub_logger.pyi (1520 bytes) (38 lines)
+│       ├── 📁 monitoring
+│       │   ├── 🐍 __init__.py (168 bytes) (10 lines)
+│       │   └── 🐍 host_monitor.py (12902 bytes) (350 lines)
+│       └── 📁 time
+│           ├── 🐍 __init__.py (398 bytes) (16 lines)
+│           ├── 🐍 _helpers.py (2824 bytes) (91 lines)
+│           ├── 🐍 _time_class.py (11425 bytes) (316 lines)
+│           ├── 🐍 _timer.py (2463 bytes) (80 lines)
+│           ├── 🐍 _tools.py (456 bytes) (17 lines)
+│           └── 🐍 time_manager.py (7731 bytes) (218 lines)
+└── 📁 tests
+    ├── 🐍 __init__.py (0 bytes) (0 lines)
+    ├── 🐍 test_add_ord_suffix.py (329 bytes) (12 lines)
+    ├── 🐍 test_clipboard.py (1799 bytes) (50 lines)
+    ├── 🐍 test_default_shell.py (154 bytes) (7 lines)
+    ├── 🐍 test_logger.py (8513 bytes) (227 lines)
+    ├── 🐍 test_platform_utils.py (922 bytes) (35 lines)
+    └── 🐍 test_time_parsing.py (414 bytes) (13 lines)

bear_utils-0.7.15/maskfile.md

@@ -0,0 +1,57 @@
+# Singleton Mask File
+
+## clean
+
+> This command cleans the build artifacts
+
+```bash
+rm -rf dist/
+```
+
+## bump (patch_version)
+
+> Bump the version of the local project specifying the patch level: `minor`, `major`, `patch`
+
+```bash
+bump2version ${patch_version} --allow-dirty
+```
+
+## build
+
+> This command builds the project via uv
+
+```bash
+uv build
+```
+
+## test
+
+> This command runs the tests using pytest
+
+```bash
+pytest -s
+```
+
+## publish (publish_location)
+
+> This command publishes the package to PyPI (or locally) officially, isn't that great?
+
+```bash
+if [ "${publish_location}" = "local" ]; then
+    twine upload -r local dist/* # uploads to a local repository
+else
+    export UV_PUBLISH_TOKEN=$(op read "op://Private/PyPI Prod/api_key")
+    uv publish --index pypi dist/* --token $UV_PUBLISH_TOKEN
+fi
+```
+
+## full (patch_version) (publish_location)
+
+> This command runs the full build and publish process
+
+```bash
+$MASK clean
+$MASK bump ${patch_version}
+$MASK build
+$MASK publish ${publish_location}
+```

{bear_utils-0.7.14 → bear_utils-0.7.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.7.14"
+version = "0.7.15"
 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"
@@ -22,8 +22,8 @@ dependencies = [
 ]
 
 [build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
-build-backend = "poetry.core.masonry.api"
+requires = ["hatchling"]
+build-backend = "hatchling.build"
 
 [dependency-groups]
 dev = [

{bear_utils-0.7.14 → bear_utils-0.7.15}/src/bear_utils/cli/__init__.py

@@ -1,4 +1,4 @@
-from .commands import MaskShellCommand, OPShellCommand, UVShellCommand
+from .commands import GitCommand, MaskShellCommand, OPShellCommand, UVShellCommand
 from .shell._base_command import BaseShellCommand
 from .shell._base_shell import SimpleShellSession, shell_session
 from .shell._common import DEFAULT_SHELL

{bear_utils-0.7.14 → bear_utils-0.7.15}/src/bear_utils/cli/commands.py

@@ -52,8 +52,48 @@ class MaskShellCommand(BaseShellCommand):
         return cls.sub("init", *args, **kwargs)
 
 
+class GitCommand(BaseShellCommand):
+    """Base class for Git commands"""
+
+    command_name = "git"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @classmethod
+    def init(cls, *args, **kwargs) -> "GitCommand":
+        """Initialize a new Git repository"""
+        return cls.sub("init", *args, **kwargs)
+
+    @classmethod
+    def status(cls, *args, **kwargs) -> "GitCommand":
+        """Get the status of the Git repository"""
+        return cls.sub("status", *args, **kwargs)
+
+    @classmethod
+    def log(cls, *args, **kwargs) -> "GitCommand":
+        """Show the commit logs"""
+        return cls.sub("log", *args, **kwargs)
+
+    @classmethod
+    def add(cls, files, *args, **kwargs) -> "GitCommand":
+        """Add files to the staging area"""
+        return cls.sub("add", *args, **kwargs).value(files)
+
+    @classmethod
+    def diff(cls, *args, **kwargs) -> "GitCommand":
+        """Show changes between commits, commit and working tree, etc."""
+        return cls.sub("diff", *args, **kwargs)
+
+    @classmethod
+    def commit(cls, message: str, *args, **kwargs) -> "GitCommand":
+        """Commit changes with a message"""
+        return cls.sub("commit -m", *args, **kwargs).value(f"'{message}'")
+
+
 __all__ = [
     "MaskShellCommand",
     "OPShellCommand",
     "UVShellCommand",
+    "GitCommand",
 ]

{bear_utils-0.7.14 → bear_utils-0.7.15}/src/bear_utils/cli/shell/_base_command.py

@@ -1,3 +1,5 @@
+from asyncio.subprocess import Process
+from subprocess import CompletedProcess
 from typing import ClassVar, Generic, Self, TypeVar
 
 T = TypeVar("T", bound=str)
@@ -56,13 +58,12 @@ class BaseShellCommand(Generic[T]):
             return f"{joined} {self.suffix}"
         return joined
 
-    def do(self) -> Self:
+    def do(self, **kwargs) -> Self:
         """Run the command using subprocess"""
         from ._base_shell import shell_session
 
-        with shell_session() as session:
-            session.add(str(self))
-            self.result = session.run()
+        with shell_session(**kwargs) as session:
+            self.result: CompletedProcess[str] | Process = session.add(self.cmd).run()
         return self
 
     def get(self) -> str:

bear_utils-0.7.15/test.py

@@ -0,0 +1,24 @@
+from bear_utils.extras._tools import copy_to_clipboard_async
+
+
+async def copy(output: str) -> int:
+    """
+    Asynchronously copy the output to the clipboard.
+
+    Args:
+        output (str): The output to copy to the clipboard.
+
+    Returns:
+        int: The return code of the command.
+    """
+    return await copy_to_clipboard_async(output)
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    async def main():
+        result = await copy("Hello, World!")
+        print(f"Copy result: {result}")
+
+    asyncio.run(main())

bear_utils-0.7.15/tests/test_add_ord_suffix.py

@@ -0,0 +1,12 @@
+import importlib
+
+
+def test_add_ord_suffix_import():
+    module = importlib.import_module("src.bear_utils.time")
+    assert hasattr(module, "add_ord_suffix")
+    func = module.add_ord_suffix
+    assert callable(func)
+    assert func(1) == "1st"
+    assert func(2) == "2nd"
+    assert func(3) == "3rd"
+    assert func(4) == "4th"

bear_utils-0.7.15/tests/test_clipboard.py

@@ -0,0 +1,50 @@
+from unittest.mock import patch
+
+import pytest
+
+from src.bear_utils.extras._tools import ClipboardManager
+from bear_utils.extras.platform_utils import OS
+
+
+@patch("src.bear_utils.extras._tools.get_platform", return_value=OS.DARWIN)
+def test_macos_commands(mock_platform):
+    manager = ClipboardManager()
+    assert manager._copy.cmd == "pbcopy"
+    assert manager._paste.cmd == "pbpaste"
+
+
+@patch("src.bear_utils.extras._tools.shutil.which")
+@patch("src.bear_utils.extras._tools.get_platform", return_value=OS.LINUX)
+def test_linux_wayland(mock_platform, mock_which):
+    mock_which.side_effect = lambda name: f"/usr/bin/{name}" if name in {"wl-copy", "wl-paste"} else None
+    manager = ClipboardManager()
+    assert manager._copy.cmd == "wl-copy"
+    assert manager._paste.cmd == "wl-paste"
+
+
+@patch("src.bear_utils.extras._tools.shutil.which")
+@patch("src.bear_utils.extras._tools.get_platform", return_value=OS.LINUX)
+def test_linux_xclip(mock_platform, mock_which):
+    def which(name: str):
+        if name == "xclip":
+            return "/usr/bin/xclip"
+        return None
+
+    mock_which.side_effect = which
+    manager = ClipboardManager()
+    assert manager._copy.cmd == "xclip -selection clipboard"
+    assert manager._paste.cmd == "xclip -selection clipboard -o"
+
+
+@patch("src.bear_utils.extras._tools.shutil.which", return_value=None)
+@patch("src.bear_utils.extras._tools.get_platform", return_value=OS.LINUX)
+def test_linux_no_clipboard(mock_platform, mock_which):
+    with pytest.raises(RuntimeError):
+        ClipboardManager()
+
+
+@patch("src.bear_utils.extras._tools.get_platform", return_value=OS.WINDOWS)
+def test_windows_commands(mock_platform):
+    manager = ClipboardManager()
+    assert manager._copy.cmd == "clip"
+    assert manager._paste.cmd == "powershell Get-Clipboard"

bear_utils-0.7.15/tests/test_default_shell.py

@@ -0,0 +1,7 @@
+from pathlib import Path
+
+from src.bear_utils.cli import DEFAULT_SHELL
+
+
+def test_default_shell_exists() -> None:
+    assert Path(DEFAULT_SHELL).exists()

bear_utils-0.7.15/tests/test_gradient.py

@@ -0,0 +1,49 @@
+import pytest
+
+
+@pytest.mark.visual
+def test_gradients_visual():
+
+    from rich.color_triplet import ColorTriplet
+    from rich.console import Console
+
+    from src.bear_utils.graphics import ColorGradient
+
+    console = Console()
+
+    # Health meter goes from red (low health) to green (full health)
+    health_gradient = ColorGradient()
+
+    console.print("🏥 [bold]Health Meter Demonstration[/bold] 🏥\n")
+
+    # Normal health: Red (low) -> Green (high)
+    console.print("[bold green]Normal Health Levels (0% = Critical, 100% = Perfect):[/bold green]")
+    for health in range(0, 101, 10):
+        color: ColorTriplet = health_gradient.map_to_color(0, 100, health)
+        health_bar = "█" * (health // 5)
+        console.print(f"HP: {health:3d}/100 {health_bar:<20}", style=color.rgb)
+
+    console.print("\n" + "=" * 50 + "\n")
+
+    # Reversed: Infection/Damage meter (Green = good, Red = bad)
+    console.print("[bold red]Infection Level (0% = Healthy, 100% = Critical):[/bold red]")
+    health_gradient.reverse = True
+    for infection in range(0, 101, 10):
+        color: ColorTriplet = health_gradient.map_to_color(0, 100, infection)
+        infection_bar = "█" * (infection // 5)
+        status = "🦠" if infection > 70 else "⚠️" if infection > 30 else "✅"
+        console.print(f"Infection: {infection:3d}% {infection_bar:<20} {status}", style=color.rgb)
+
+    health_scenarios = [
+        (5, "💀 Nearly Dead"),
+        (25, "🩸 Critical Condition"),
+        (50, "⚠️  Wounded"),
+        (75, "😐 Recovering"),
+        (95, "💪 Almost Full Health"),
+        (100, "✨ Perfect Health"),
+    ]
+
+    console.print("[bold green]Health Status Examples:[/bold green]")
+    for hp, status in health_scenarios:
+        color: ColorTriplet = health_gradient.map_to_color(0, 100, hp)
+        console.print(f"{status}: {hp}/100 HP", style=color.rgb)