bear-utils 0.9.2__py3-none-any.whl → 0.9.3__py3-none-any.whl

bear_utils/_internal/_version.py

@@ -1 +1 @@
-version = "0.9.2"
+version = "0.9.3"

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/_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/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/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/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,65 @@ 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: Self = str.__new__(cls, value.value)
+        obj._value_ = value.value
         obj.text = 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 +88,14 @@ 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: Self = int.__new__(cls, value.value)
+        obj._value_ = value.value
         obj.text = text
+        obj.default = value.default
         return obj
 
     def __int__(self) -> int:
@@ -58,18 +103,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 +141,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 +157,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 +191,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/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",
 ]

bear_utils/extras/_tools.py

@@ -1,15 +1,13 @@
 import asyncio
 from asyncio.subprocess import PIPE
 from collections import deque
-from functools import cached_property
 import shutil
 from typing import TYPE_CHECKING
 
-from rich.console import Console
-
 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.graphics.font._utils import ascii_header
 
 if TYPE_CHECKING:
     from subprocess import CompletedProcess
@@ -175,119 +173,13 @@ async def clear_clipboard_async() -> int:
     return await clipboard_manager.clear()
 
 
-class TextHelper:
-    @cached_property
-    def local_console(self) -> Console:
-        return Console()
-
-    def print_header(
-        self,
-        title: str,
-        top_sep: str = "#",
-        left_sep: str = ">",
-        right_sep: str = "<",
-        bottom_sep: str = "#",
-        length: int = 60,
-        s1: str = "bold red",
-        s2: str = "bold blue",
-        return_txt: bool = False,
-    ) -> str:
-        """Generate a header string with customizable separators for each line.
-
-        Args:
-            title: The title text to display
-            top_sep: Character(s) for the top separator line
-            left_sep: Character(s) for the left side of title line
-            right_sep: Character(s) for the right side of title line
-            bottom_sep: Character(s) for the bottom separator line
-            length: Total width of each line
-            s1: Style for the title text
-            s2: Style for the entire header block
-            return_txt: If True, return the text instead of printing
-        """
-        # Top line: all top_sep characters
-        top_line: str = top_sep * length
-
-        # Bottom line: all bottom_sep characters
-        bottom_line: str = bottom_sep * length
-
-        # Title line: left_sep chars + title + right_sep chars
-        title_with_spaces = f" {title} "
-        styled_title = f"[{s1}]{title}[/{s1}]"
-
-        # Calculate padding needed on each side
-        title_length = len(title_with_spaces)
-        remaining_space = length - title_length
-        left_padding = remaining_space // 2
-        right_padding = remaining_space - left_padding
-
-        # Build the title line with different left and right separators
-        title_line = (
-            (left_sep * left_padding) + title_with_spaces.replace(title, styled_title) + (right_sep * right_padding)
-        )
-
-        # Assemble the complete header
-        output_text: str = f"\n{top_line}\n{title_line}\n{bottom_line}\n"
-
-        if not return_txt:
-            self.local_console.print(output_text, style=s2)
-        return output_text
-
-
-def ascii_header(
-    title: str,
-    top_sep: str = "#",
-    left_sep: str = ">",
-    right_sep: str = "<",
-    bottom_sep: str = "#",
-    length: int = 60,
-    style1: str = "bold red",
-    style2: str = "bold blue",
-    print_out: bool = True,
-) -> str:
-    """Generate a header string for visual tests.
-
-    Args:
-        title (str): The title to display in the header.
-        top_sep (str): The character to use for the top separator line. Defaults to '#'.
-        left_sep (str): The character to use for the left side of title line. Defaults to '>'.
-        right_sep (str): The character to use for the right side of title line. Defaults to '<'.
-        bottom_sep (str): The character to use for the bottom separator line. Defaults to '#'.
-        length (int): The total length of the header line. Defaults to 60.
-        style1 (str): The style for the title text. Defaults to 'bold red'.
-        style2 (str): The style for the separator text. Defaults to 'bold blue'.
-        print_out (bool): Whether to print the header or just return it. Defaults to True.
-    """
-    text_helper = TextHelper()
-    if print_out:
-        text_helper.print_header(
-            title=title,
-            top_sep=top_sep,
-            left_sep=left_sep,
-            right_sep=right_sep,
-            bottom_sep=bottom_sep,
-            length=length,
-            s1=style1,
-            s2=style2,
-            return_txt=False,
-        )
-        return ""
-    return text_helper.print_header(
-        title=title,
-        top_sep=top_sep,
-        left_sep=left_sep,
-        right_sep=right_sep,
-        bottom_sep=bottom_sep,
-        length=length,
-        s1=style1,
-        s2=style2,
-        return_txt=True,
-    )
-
-
-if __name__ == "__main__":
-    # Example usage of the TextHelper
-    text_helper = TextHelper()
-    text_helper.print_header("My Title", top_sep="#", bottom_sep="#")
-    text_helper.print_header("My Title", top_sep="=", left_sep=">", right_sep="<", bottom_sep="=")
-    text_helper.print_header("My Title", top_sep="-", left_sep="[", right_sep="]", bottom_sep="-")
+__all__ = [
+    "ClipboardManager",
+    "ascii_header",
+    "clear_clipboard",
+    "clear_clipboard_async",
+    "copy_to_clipboard",
+    "copy_to_clipboard_async",
+    "paste_from_clipboard",
+    "paste_from_clipboard_async",
+]