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

bear_utils/_internal/_version.py

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

bear_utils/_internal/cli.py

@@ -15,6 +15,9 @@ import sys
 from typing import Any
 
 from bear_utils._internal import debug
+from bear_utils._internal._version import version as _version
+from bear_utils.cli._get_version import VALID_BUMP_TYPES, cli_bump
+from bear_utils.constants import ExitCode
 
 
 class _DebugInfo(Action):
@@ -23,7 +26,7 @@ class _DebugInfo(Action):
 
     def __call__(self, *_: Any, **__: Any) -> None:
         debug._print_debug_info()
-        sys.exit(0)
+        sys.exit(ExitCode.SUCCESS)
 
 
 class _About(Action):
@@ -32,20 +35,52 @@ class _About(Action):
 
     def __call__(self, *_: Any, **__: Any) -> None:
         print(debug._get_package_info())
-        sys.exit(0)
+        sys.exit(ExitCode.SUCCESS)
+
+
+class _Version(Action):
+    def __init__(self, nargs: int | str | None = 0, **kwargs: Any) -> None:
+        super().__init__(nargs=nargs, **kwargs)
+
+    def __call__(self, *_: Any, **__: Any) -> None:
+        version: str = f"{debug._get_name()} v{_version}"
+        print(version)
+        sys.exit(ExitCode.SUCCESS)
+
+
+def get_version() -> ExitCode:
+    """CLI command to get the version of the package."""
+    print(_version)
+    return ExitCode.SUCCESS
+
+
+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(
+        "bump_type",
+        type=str,
+        choices=VALID_BUMP_TYPES,
+        help=f"Type of version bump: {', '.join(VALID_BUMP_TYPES)}",
+    )
+    _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: str = debug._get_name()
-    version: str = f"{name} v{debug._get_version()}"
+    name = debug._get_name()
     parser = ArgumentParser(description=name.capitalize(), prog=name, exit_on_error=False)
-    parser.add_argument("-V", "--version", action="version", version=version)
+    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
@@ -62,11 +97,22 @@ 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 1
-    return 0
+        return ExitCode.FAILURE
+    return ExitCode.SUCCESS
 
 
 if __name__ == "__main__":

bear_utils/_internal/debug.py

@@ -1,12 +1,15 @@
 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
 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"
 
 
@@ -16,11 +19,22 @@ class _Package:
 
     name: str = __PACKAGE_NAME__
     """Package name."""
-    version: str = "0.0.0"
+    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}"
@@ -69,7 +83,7 @@ def _get_package_info(dist: str = __PACKAGE_NAME__) -> _Package:
     try:
         return _Package(
             name=dist,
-            version=version(dist),
+            version=_version or version(dist),
             description=metadata(dist)["Summary"],
         )
     except PackageNotFoundError:
@@ -156,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

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from argparse import ArgumentParser, Namespace
+from contextlib import redirect_stdout
+from importlib.metadata import PackageNotFoundError, version
+from io import StringIO
+import sys
+from typing import Literal, Self
+
+from pydantic import BaseModel
+
+from bear_utils.constants import ExitCode
+from bear_utils.constants._meta import IntValue as Value, RichIntEnum
+from bear_utils.extras import zap_as
+
+
+class VerParts(RichIntEnum):
+    """Enumeration for version parts."""
+
+    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.text for version_part in cls]
+
+    @classmethod
+    def parts(cls) -> int:
+        """Return the total number of version parts."""
+        return len(cls.choices())
+
+
+VALID_BUMP_TYPES: list[str] = VerParts.choices()
+ALL_PARTS: int = VerParts.parts()
+
+
+class Version(BaseModel):
+    """Model to represent a version string."""
+
+    major: int = 0
+    """Major version number."""
+    minor: int = 0
+    """Minor version number."""
+    patch: int = 0
+    """Patch version number."""
+
+    @classmethod
+    def from_string(cls, version_str: str) -> Self:
+        """Create a Version instance from a version string.
+
+        Args:
+            version_str: A version string in the format "major.minor.patch".
+
+        Returns:
+            A Version instance.
+
+        Raises:
+            ValueError: If the version string is not in the correct format.
+        """
+        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:
+        """Return the version as a string in the format "major.minor.patch".
+
+        Returns:
+            A string representation of the version.
+        """
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+    def default(self, part: str) -> None:
+        """Clear the specified part of the version.
+
+        Args:
+            part: The part of the version to clear.
+        """
+        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
+    def from_func(cls, package_name: str) -> Self:
+        """Create a Version instance from the current package version.
+
+        Returns:
+            A Version instance with the current package version.
+
+        Raises:
+            PackageNotFoundError: If the package is not found.
+        """
+        try:
+            current_version = version(package_name)
+            return cls.from_string(current_version)
+        except PackageNotFoundError as e:
+            raise PackageNotFoundError(f"Package '{package_name}' not found: {e}") from e
+
+
+def _bump_version(version: str, bump_type: Literal["major", "minor", "patch"]) -> Version:
+    """Bump the version based on the specified type.
+
+    Args:
+        version: The current version string (e.g., "1.2.3").
+        bump_type: The type of bump ("major", "minor", or "patch").
+
+    Returns:
+        The new version string.
+
+    Raises:
+        ValueError: If the version format is invalid or bump_type is unsupported.
+    """
+    ver: Version = Version.from_string(version)
+    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.
+
+    Returns:
+        The version of the package.
+    """
+    if args is None:
+        args = sys.argv[1:]
+    parser = ArgumentParser(description="Get the version of the package.")
+    parser.add_argument("package_name", nargs="?", type=str, help="Name of the package to get the version for.")
+    arguments: Namespace = parser.parse_args(args)
+    if not arguments.package_name:
+        print("No package name provided. Please specify a package name.")
+        return ExitCode.FAILURE
+    package_name: str = arguments.package_name
+    try:
+        current_version = version(package_name)
+        print(current_version)
+    except PackageNotFoundError:
+        print(f"Package '{package_name}' not found.")
+        return ExitCode.FAILURE
+    return ExitCode.SUCCESS
+
+
+def cli_bump(args: list[str] | None = None) -> ExitCode:
+    if args is None:
+        args = sys.argv[1:]
+    parser = ArgumentParser(description="Bump the version of the package.")
+    parser.add_argument("bump_type", type=str, choices=VALID_BUMP_TYPES, default="patch")
+    parser.add_argument("package_name", nargs="?", type=str, help="Name of the package to bump the version for.")
+    parser.add_argument("current_version", type=str, help="Current version of the package.")
+    arguments: Namespace = parser.parse_args(args)
+    bump_type: Literal["major", "minor", "patch"] = arguments.bump_type
+    if not arguments.package_name:
+        print("No package name provided.")
+        return ExitCode.FAILURE
+    package_name: str = arguments.package_name
+    if bump_type not in VALID_BUMP_TYPES:
+        print(f"Invalid argument '{bump_type}'. Use one of: {', '.join(VALID_BUMP_TYPES)}.")
+        return ExitCode.FAILURE
+    current_version: str = arguments.current_version or _get_version(package_name)
+    try:
+        new_version: Version = _bump_version(version=current_version, bump_type=bump_type)
+        print(new_version.version_string)
+        return ExitCode.SUCCESS
+    except ValueError as e:
+        print(f"Error: {e}")
+        return ExitCode.FAILURE
+    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/__init__.py

@@ -9,6 +9,7 @@ from bear_utils.constants._exit_code import (
     COMMAND_NOT_FOUND,
     EXIT_STATUS_OUT_OF_RANGE,
     FAIL,
+    FAILURE,
     INVALID_ARGUMENT_TO_EXIT,
     MISUSE_OF_SHELL_COMMAND,
     PROCESS_KILLED_BY_SIGKILL,
@@ -28,7 +29,7 @@ from bear_utils.constants._http_status_code import (
     UNAUTHORIZED,
     HTTPStatusCode,
 )
-from bear_utils.constants._meta import NullFile, RichIntEnum, Value
+from bear_utils.constants._meta import IntValue, NullFile, RichIntEnum, RichStrEnum, StrValue
 
 VIDEO_EXTS = [".mp4", ".mov", ".avi", ".mkv"]
 """Extensions for video files."""
@@ -58,6 +59,7 @@ __all__ = [
     "CONFLICT",
     "EXIT_STATUS_OUT_OF_RANGE",
     "FAIL",
+    "FAILURE",
     "FILE_EXTS",
     "FORBIDDEN",
     "GLOBAL_VENV",
@@ -80,7 +82,9 @@ __all__ = [
     "VIDEO_EXTS",
     "ExitCode",
     "HTTPStatusCode",
+    "IntValue",
     "NullFile",
     "RichIntEnum",
-    "Value",
+    "RichStrEnum",
+    "StrValue",
 ]

bear_utils/constants/_exit_code.py

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

bear_utils/constants/_http_status_code.py

@@ -1,6 +1,6 @@
 """HTTP status codes."""
 
-from bear_utils.constants._meta import RichIntEnum, Value
+from bear_utils.constants._meta import IntValue as Value, RichIntEnum
 
 
 class HTTPStatusCode(RichIntEnum):

bear_utils/constants/_meta.py

@@ -1,27 +1,101 @@
+from contextlib import suppress
 from dataclasses import dataclass
-from enum import IntEnum
-from typing import Any, Self, TextIO
+from enum import IntEnum, StrEnum
+from typing import Any, Self, TextIO, overload
 
 
 @dataclass(frozen=True)
-class Value:
-    """A frozen dataclass for holding constant values."""
+class IntValue:
+    """A frozen dataclass for holding constant integer values."""
 
     value: int
     text: str
+    default: int = 0
+
+
+@dataclass(frozen=True)
+class StrValue:
+    """A frozen dataclass for holding constant string values."""
+
+    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:
+        text: str = value.text
+        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 a string representation of the enum."""
+        return self.value
+
+    def str(self) -> str:
+        """Return the string value of the enum."""
+        return self.value
 
 
 class RichIntEnum(IntEnum):
     """Base class for IntEnums with rich metadata."""
 
     text: str
+    default: int
 
-    def __new__(cls, value: Value) -> Self:
-        _value: int = value.value
+    def __new__(cls, value: IntValue) -> Self:
         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:
@@ -29,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:
@@ -52,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
@@ -67,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."""
@@ -101,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",
 ]