bear-utils 0.9.2__tar.gz → 0.9.4__tar.gz

{bear_utils-0.9.2 → bear_utils-0.9.4}/.gitignore

@@ -164,6 +164,8 @@ cython_debug/
 
 **/.vscode
 
+*.db
+*.log
 src/bear_utils/_internal/_version.pyi
 src/bear_utils/_internal/_version.py
 uv.lock

{bear_utils-0.9.2 → bear_utils-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.9.2
+Version: 0.9.4
 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
@@ -12,6 +12,7 @@ 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: pyfiglet>=1.0.3
 Requires-Dist: pyglm<3.0.0,>=2.8.2
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich<15.0.0,>=14.0.0

{bear_utils-0.9.2 → bear_utils-0.9.4}/config/ruff.toml

@@ -109,3 +109,4 @@ exclude = [
 ]
 docstring-code-format = true
 docstring-code-line-length = 80
+skip-magic-trailing-comma = false

{bear_utils-0.9.2 → bear_utils-0.9.4}/maskfile.md

@@ -14,7 +14,7 @@ rm -rf dist/
 
 ```bash
 uv sync
-current_version=$(uv run get-version bear-utils)
+current_version=$(python3 -m bear_utils._internal.cli get-version)
 echo "Current version: ${current_version}"
 if [ -z "${patch_version}" ]; then
     echo "Please specify a patch version: minor, major, or patch"
@@ -29,7 +29,15 @@ if [ -z "${current_version}" ]; then
     echo "Current version is not set. Please run 'uv run get-version' first."
     exit 1
 fi
-new_version=$(uv run bump ${patch_version})
+new_version=$(python3 -m bear_utils._internal.cli bump-version "${patch_version}")
+if [ $? -ne 0 ]; then
+    echo "Failed to bump version. Please check the current version and try again."
+    exit 1
+fi
+if [ -z "${new_version}" ]; then
+    echo "Failed to bump version. Please check the current version and try again."
+    exit 1
+fi
 echo "New version: ${new_version}"  
 git tag -a "v${new_version}" -m "Bump version to v${new_version}"
 git push origin "v${new_version}"

{bear_utils-0.9.2 → bear_utils-0.9.4}/pyproject.toml

@@ -23,6 +23,7 @@ dependencies = [
     "uvicorn>=0.35.0",
     "bear-epoch-time>=1.1.4",
     "typer>=0.16.0",
+    "pyfiglet>=1.0.3",
 ]
 
 [project.optional-dependencies]
@@ -30,9 +31,9 @@ gui = [
     "pyqt6>=6.9.0",
 ]
 
-[project.scripts]
-get-version = "bear_utils._internal.cli:get_version"
-bump = "bear_utils._internal.cli:bump_version"
+# [project.scripts]
+# get-version = "bear_utils._internal.cli:get_version"
+# bump = "bear_utils._internal.cli:bump_version"
 
 [build-system]
 requires = ["hatchling", "uv-dynamic-versioning"]
@@ -55,7 +56,6 @@ ci = [
     "types-markdown>=3.6",
     "types-pyyaml>=6.0",
     "nox>=2025.5.1",
-    "bump2version>=1.0.1",
     "twine>=6.1.0",
 ]
 gui = [
@@ -81,7 +81,8 @@ filterwarnings = [
 ]
 
 [tool.pyright]
-include = ["src"]
+include = ["src", "tests"]
+testpaths = ["tests"]
 exclude = ["**/__pycache__"]
 venvPath = "."
 venv = ".venv"
@@ -97,6 +98,7 @@ source = "uv-dynamic-versioning"
 vcs = "git"
 style = "semver"
 metadata = false
+format = "{base}"
 
 [tool.hatch.build.hooks.version]
 path = "src/bear_utils/_internal/_version.py"

bear_utils-0.9.4/src/bear_utils/_internal/_version.py

@@ -0,0 +1 @@
+version = "0.9.4"

{bear_utils-0.9.2 → bear_utils-0.9.4}/src/bear_utils/_internal/cli.py

@@ -54,7 +54,7 @@ def get_version() -> ExitCode:
     return ExitCode.SUCCESS
 
 
-def bump_version() -> ExitCode:
+def bump_version(args: list[str] | None = None) -> ExitCode:
     """CLI command to bump the version of the package."""
     parser = ArgumentParser(description="Bump the version of the package.")
     parser.add_argument(
@@ -63,21 +63,24 @@ def bump_version() -> ExitCode:
         choices=VALID_BUMP_TYPES,
         help=f"Type of version bump: {', '.join(VALID_BUMP_TYPES)}",
     )
-    args: Namespace = parser.parse_args(sys.argv[1:])
-    bump_args = [args.bump_type, debug.__PACKAGE_NAME__, _version]
-    return cli_bump(bump_args)
+    _args: Namespace = parser.parse_args(args or sys.argv[1:])
+    return cli_bump([_args.bump_type, debug.__PACKAGE_NAME__, _version])
 
 
 def get_parser() -> ArgumentParser:
     name = debug._get_name()
     parser = ArgumentParser(description=name.capitalize(), prog=name, exit_on_error=False)
     parser.add_argument("-V", "--version", action=_Version, help="Print the version of the package")
+    subparser = parser.add_subparsers(dest="command", required=False, help="Available commands")
+    subparser.add_parser("get-version", help="Get the current version of the package")
+    bump = subparser.add_parser("bump-version", help="Bump the version of the package")
+    bump.add_argument("bump_type", type=str, choices=VALID_BUMP_TYPES, help="major, minor, or patch")
     parser.add_argument("--about", action=_About, help="Print information about the package")
     parser.add_argument("--debug_info", action=_DebugInfo, help="Print debug information")
     return parser
 
 
-def main(args: list[str] | None = None) -> int:
+def main(args: list[str] | None = None) -> ExitCode:
     """Main entry point for the CLI.
 
     This function is called when the CLI is executed. It can be used to
@@ -94,7 +97,18 @@ def main(args: list[str] | None = None) -> int:
     try:
         parser: ArgumentParser = get_parser()
         opts: Namespace = parser.parse_args(args)
-        print(opts)
+        command = opts.command
+        if command is None:
+            parser.print_help()
+            return ExitCode.SUCCESS
+        if command == "get-version":
+            return get_version()
+        if command == "bump-version":
+            if not hasattr(opts, "bump_type"):
+                print("Error: 'bump-version' command requires a 'bump_type' argument.", file=sys.stderr)
+                return ExitCode.FAILURE
+            bump_type = opts.bump_type
+            return bump_version([bump_type])
     except Exception as e:
         print(f"Error initializing CLI: {e}", file=sys.stderr)
         return ExitCode.FAILURE

{bear_utils-0.9.2 → bear_utils-0.9.4}/src/bear_utils/_internal/debug.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 import importlib.metadata
 from importlib.metadata import PackageNotFoundError, metadata, version
 import os
@@ -8,6 +8,7 @@ import platform
 import sys
 
 from bear_utils._internal._version import version as _version
+from bear_utils.cli._get_version import Version
 
 __PACKAGE_NAME__ = "bear-utils"
 
@@ -20,9 +21,20 @@ class _Package:
     """Package name."""
     version: str = _version
     """Package version."""
+    _version: Version = field(default_factory=lambda: Version.from_string(_version))
     description: str = "No description available."
     """Package description."""
 
+    def __post_init__(self) -> None:
+        """Post-initialization to ensure version is a string."""
+        if not isinstance(self.version, str) or "0.0.0" in self.version:
+            self.version = version(self.name) if self.name else "0.0.0"
+        if not self.description:
+            try:
+                self.description = metadata(self.name)["Summary"]
+            except PackageNotFoundError:
+                self.description = "No description available."
+
     def __str__(self) -> str:
         """String representation of the package information."""
         return f"{self.name} v{self.version}: {self.description}"
@@ -158,4 +170,5 @@ def _print_debug_info() -> None:
 
 
 if __name__ == "__main__":
-    _print_debug_info()
+    # _print_debug_info()
+    print(_get_package_info())

{bear_utils-0.9.2 → bear_utils-0.9.4}/src/bear_utils/cli/_get_version.py

@@ -10,42 +10,40 @@ from typing import Literal, Self
 from pydantic import BaseModel
 
 from bear_utils.constants import ExitCode
-from bear_utils.constants._meta import RichStrEnum, StrValue as Value
+from bear_utils.constants._meta import IntValue as Value, RichIntEnum
+from bear_utils.extras import zap_as
 
 
-class VersionParts(RichStrEnum):
+class VerParts(RichIntEnum):
     """Enumeration for version parts."""
 
-    MAJOR = Value("major", "Major version")
-    MINOR = Value("minor", "Minor version")
-    PATCH = Value("patch", "Patch version")
+    MAJOR = Value(0, "major")
+    MINOR = Value(1, "minor")
+    PATCH = Value(2, "patch")
 
     @classmethod
     def choices(cls) -> list[str]:
         """Return a list of valid version parts."""
-        return [version_part.value for version_part in cls]
+        return [version_part.text for version_part in cls]
 
     @classmethod
-    def num(cls) -> int:
-        """Return the number of valid version parts."""
+    def parts(cls) -> int:
+        """Return the total number of version parts."""
         return len(cls.choices())
 
 
-VALID_BUMP_TYPES: list[str] = VersionParts.choices()
-NUM_PARTS: int = VersionParts.num()
-MAJOR = VersionParts.MAJOR.str()
-MINOR = VersionParts.MINOR.str()
-PATCH = VersionParts.PATCH.str()
+VALID_BUMP_TYPES: list[str] = VerParts.choices()
+ALL_PARTS: int = VerParts.parts()
 
 
 class Version(BaseModel):
     """Model to represent a version string."""
 
-    major: int
+    major: int = 0
     """Major version number."""
-    minor: int
+    minor: int = 0
     """Minor version number."""
-    patch: int
+    patch: int = 0
     """Patch version number."""
 
     @classmethod
@@ -61,10 +59,17 @@ class Version(BaseModel):
         Raises:
             ValueError: If the version string is not in the correct format.
         """
-        parts = version_str.split(".")
-        if len(parts) != VersionParts.num() or not all(part.isdigit() for part in parts):
-            raise ValueError(f"Invalid version format: {version_str}")
-        return cls(major=int(parts[0]), minor=int(parts[1]), patch=int(parts[2]))
+        try:
+            major, minor, patch = zap_as("-+", version_str, 3, replace=".", func=int)
+            return cls(major=int(major), minor=int(minor), patch=int(patch))
+        except ValueError as e:
+            raise ValueError(
+                f"Invalid version string format: {version_str}. Expected integers for major, minor, and patch."
+            ) from e
+
+    def increment(self, attr_name: str) -> None:
+        """Increment the specified part of the version."""
+        setattr(self, attr_name, getattr(self, attr_name) + 1)
 
     @property
     def version_string(self) -> str:
@@ -75,30 +80,22 @@ class Version(BaseModel):
         """
         return f"{self.major}.{self.minor}.{self.patch}"
 
-    def new_version(self, bump_type: Literal["major", "minor", "patch"]) -> Version:
-        """Return a new version string based on the bump type.
+    def default(self, part: str) -> None:
+        """Clear the specified part of the version.
 
         Args:
-            bump_type: The type of bump ("major", "minor", or "patch").
-
-        Returns:
-            A new version string.
-
-        Raises:
-            ValueError: If the bump_type is unsupported.
+            part: The part of the version to clear.
         """
-        match bump_type:
-            case VersionParts.MAJOR:
-                self.major += 1
-                self.minor = 0
-                self.patch = 0
-            case VersionParts.MINOR:
-                self.minor += 1
-                self.patch = 0
-            case VersionParts.PATCH:
-                self.patch += 1
-            case _:
-                raise ValueError(f"Unsupported bump type: {bump_type}")
+        if hasattr(self, part):
+            setattr(self, part, 0)
+
+    def new_version(self, bump_type: str) -> Version:
+        """Return a new version string based on the bump type."""
+        bump_part: VerParts = VerParts.get(bump_type, default=VerParts.PATCH)
+        self.increment(bump_part.text)
+        for part in VerParts:
+            if part.value > bump_part.value:
+                self.default(part.text)
         return self
 
     @classmethod
@@ -135,6 +132,24 @@ def _bump_version(version: str, bump_type: Literal["major", "minor", "patch"]) -
     return ver.new_version(bump_type)
 
 
+def _get_version(package_name: str) -> str:
+    """Get the version of the specified package.
+
+    Args:
+        package_name: The name of the package to get the version for.
+
+    Returns:
+        A Version instance representing the current version of the package.
+
+    Raises:
+        PackageNotFoundError: If the package is not found.
+    """
+    record = StringIO()
+    with redirect_stdout(record):
+        cli_get_version([package_name])
+    return record.getvalue().strip()
+
+
 def cli_get_version(args: list[str] | None = None) -> ExitCode:
     """Get the version of the current package.
 
@@ -159,24 +174,6 @@ def cli_get_version(args: list[str] | None = None) -> ExitCode:
     return ExitCode.SUCCESS
 
 
-def _get_version(package_name: str) -> str:
-    """Get the version of the specified package.
-
-    Args:
-        package_name: The name of the package to get the version for.
-
-    Returns:
-        A Version instance representing the current version of the package.
-
-    Raises:
-        PackageNotFoundError: If the package is not found.
-    """
-    record = StringIO()
-    with redirect_stdout(record):
-        cli_get_version([package_name])
-    return record.getvalue().strip()
-
-
 def cli_bump(args: list[str] | None = None) -> ExitCode:
     if args is None:
         args = sys.argv[1:]
@@ -204,3 +201,7 @@ def cli_bump(args: list[str] | None = None) -> ExitCode:
     except Exception as e:
         print(f"Unexpected error: {e}")
         return ExitCode.FAILURE
+
+
+if __name__ == "__main__":
+    cli_bump(["patch", "bear-utils", "0.9.2-fart.build-alpha"])

{bear_utils-0.9.2 → bear_utils-0.9.4}/src/bear_utils/constants/_exit_code.py

@@ -1,4 +1,4 @@
-from bear_utils.constants._meta import RichIntEnum, IntValue as Value
+from bear_utils.constants._meta import IntValue as Value, RichIntEnum
 
 
 class ExitCode(RichIntEnum):

{bear_utils-0.9.2 → bear_utils-0.9.4}/src/bear_utils/constants/_meta.py

@@ -1,6 +1,7 @@
+from contextlib import suppress
 from dataclasses import dataclass
 from enum import IntEnum, StrEnum
-from typing import Any, Self, TextIO
+from typing import Any, Self, TextIO, overload
 
 
 @dataclass(frozen=True)
@@ -9,6 +10,7 @@ class IntValue:
 
     value: int
     text: str
+    default: int = 0
 
 
 @dataclass(frozen=True)
@@ -17,23 +19,64 @@ class StrValue:
 
     value: str
     text: str
+    default: str = ""
 
 
 class RichStrEnum(StrEnum):
     """Base class for StrEnums with rich metadata."""
 
     text: str
+    default: str
 
     def __new__(cls, value: StrValue) -> Self:
-        _value: str = value.value
-        text: str = value.text
-        obj: Self = str.__new__(cls, _value)
-        obj._value_ = _value
-        obj.text = text
+        obj: Self = str.__new__(cls, value.value)
+        obj._value_ = value.value
+        obj.text = value.text
+        obj.default = value.default
         return obj
 
+    @classmethod
+    def keys(cls) -> list[str]:
+        """Return a list of all enum member names."""
+        return [item.name for item in cls]
+
+    @overload
+    @classmethod
+    def get(cls, value: str | Self, default: Self) -> Self: ...
+
+    @overload
+    @classmethod
+    def get(cls, value: str | Self, default: None = None) -> None: ...
+
+    @classmethod
+    def get(cls, value: str | Self, default: Self | None = None) -> Self | None:
+        """Try to get an enum member by its value or name."""
+        if isinstance(value, cls):
+            return value
+        with suppress(ValueError):
+            if isinstance(value, str):
+                return cls.from_text(value)
+        return default
+
+    @classmethod
+    def from_text(cls, text: str) -> Self:
+        """Convert a string text to its corresponding enum member."""
+        for item in cls:
+            if item.text == text:
+                return item
+        raise ValueError(f"Text {text} not found in {cls.__name__}")
+
+    @classmethod
+    def from_name(cls, name: str) -> Self:
+        """Convert a string name to its corresponding enum member."""
+        try:
+            return cls[name.upper()]
+        except KeyError as e:
+            raise ValueError(f"Name {name} not found in {cls.__name__}") from e
+
     def __str__(self) -> str:
-        return f"{self.name} ({self.value}): {self.text}"
+        """Return a string representation of the enum."""
+        return self.value
 
     def str(self) -> str:
         """Return the string value of the enum."""
@@ -44,13 +87,13 @@ class RichIntEnum(IntEnum):
     """Base class for IntEnums with rich metadata."""
 
     text: str
+    default: int
 
     def __new__(cls, value: IntValue) -> Self:
-        _value: int = value.value
-        text: str = value.text
-        obj: Self = int.__new__(cls, _value)
-        obj._value_ = _value
-        obj.text = text
+        obj: Self = int.__new__(cls, value.value)
+        obj._value_ = value.value
+        obj.text = value.text
+        obj.default = value.default
         return obj
 
     def __int__(self) -> int:
@@ -58,18 +101,33 @@ class RichIntEnum(IntEnum):
         return self.value
 
     def __str__(self) -> str:
+        """Return a string representation of the enum."""
         return f"{self.name} ({self.value}): {self.text}"
 
     @classmethod
-    def get(cls, value: Any) -> Self:
+    def keys(cls) -> list[str]:
+        """Return a list of all enum member names."""
+        return [item.name for item in cls]
+
+    @overload
+    @classmethod
+    def get(cls, value: str | int | Self, default: Self) -> Self: ...
+
+    @overload
+    @classmethod
+    def get(cls, value: str | int | Self, default: None = None) -> None: ...
+
+    @classmethod
+    def get(cls, value: str | int | Self | Any, default: Self | None = None) -> Self | None:
         """Try to get an enum member by its value, name, or text."""
         if isinstance(value, cls):
             return value
-        if isinstance(value, int):
-            return cls.from_int(value)
-        if isinstance(value, str):
-            return cls.from_name(value)
-        raise ValueError(f"Cannot convert {value} to {cls.__name__}")
+        with suppress(ValueError):
+            if isinstance(value, int):
+                return cls.from_int(value)
+            if isinstance(value, str):
+                return cls.from_name(value)
+        return default
 
     @classmethod
     def from_name(cls, name: str) -> Self:
@@ -81,6 +139,7 @@ class RichIntEnum(IntEnum):
 
     @classmethod
     def from_int(cls, code: int) -> Self:
+        """Convert an integer to its corresponding enum member."""
         for item in cls:
             if item.value == code:
                 return item
@@ -96,11 +155,11 @@ class RichIntEnum(IntEnum):
 
 
 class MockTextIO(TextIO):
-    """A mock TextIO class that does nothing."""
+    """A mock TextIO class that captures written output for testing purposes."""
 
     def __init__(self) -> None:
         """Initialize the mock TextIO."""
-        self._buffer = []
+        self._buffer: list[str] = []
 
     def write(self, _s: str, *_) -> None:  # type: ignore[override]
         """Mock write method that appends to the buffer."""
@@ -130,6 +189,7 @@ class NullFile(TextIO):
         """Flush the null file (no operation)."""
 
     def __enter__(self) -> Self:
+        """Enter context manager and return self."""
         return self
 
     def __exit__(self, *_: object) -> None:

{bear_utils-0.9.2 → bear_utils-0.9.4}/src/bear_utils/extras/__init__.py

@@ -3,6 +3,7 @@
 from singleton_base import SingletonBase
 
 from ._tools import ClipboardManager, ascii_header, clear_clipboard, copy_to_clipboard, paste_from_clipboard
+from ._zapper import zap, zap_as, zap_as_multi, zap_get, zap_multi
 from .platform_utils import OS, get_platform, is_linux, is_macos, is_windows
 from .wrappers.add_methods import add_comparison_methods
 
@@ -19,4 +20,9 @@ __all__ = [
     "is_macos",
     "is_windows",
     "paste_from_clipboard",
+    "zap",
+    "zap_as",
+    "zap_as_multi",
+    "zap_get",
+    "zap_multi",
 ]