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

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

@@ -163,3 +163,7 @@ cython_debug/
 #.idea/
 
 **/.vscode
+
+src/bear_utils/_internal/_version.pyi
+src/bear_utils/_internal/_version.py
+uv.lock

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

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

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.9.0
+# Bear Utils
 
 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.9.0 → bear_utils-0.9.2}/maskfile.md

@@ -13,7 +13,26 @@ rm -rf dist/
 > Bump the version of the local project specifying the patch level: `minor`, `major`, `patch`
 
 ```bash
-bump2version ${patch_version} --allow-dirty
+uv sync
+current_version=$(uv run get-version bear-utils)
+echo "Current version: ${current_version}"
+if [ -z "${patch_version}" ]; then
+    echo "Please specify a patch version: minor, major, or patch"
+    exit 1
+fi
+if [ "${patch_version}" != "minor" ] && [ "${patch_version}" != "major" ] && [ "${patch_version}" != "patch" ]; then
+    echo "Invalid patch version specified. Use minor, major, or patch."
+    exit 1
+fi
+# Ensure the current version is set
+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})
+echo "New version: ${new_version}"  
+git tag -a "v${new_version}" -m "Bump version to v${new_version}"
+git push origin "v${new_version}"
 ```
 
 ## build

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

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.9.0"
+dynamic = ["version"]
 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"
@@ -30,8 +30,12 @@ gui = [
     "pyqt6>=6.9.0",
 ]
 
+[project.scripts]
+get-version = "bear_utils._internal.cli:get_version"
+bump = "bear_utils._internal.cli:bump_version"
+
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling", "uv-dynamic-versioning"]
 build-backend = "hatchling.build"
 
 [dependency-groups]
@@ -85,3 +89,17 @@ pythonVersion = "3.13"
 typeCheckingMode = "standard"
 reportMissingImports = true
 reportMissingTypeStubs = false
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv-dynamic-versioning]
+vcs = "git"
+style = "semver"
+metadata = false
+
+[tool.hatch.build.hooks.version]
+path = "src/bear_utils/_internal/_version.py"
+template = '''
+version = "{version}"
+'''

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

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

{bear_utils-0.9.0 → bear_utils-0.9.2}/src/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,14 +35,43 @@ 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() -> 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(sys.argv[1:])
+    bump_args = [args.bump_type, debug.__PACKAGE_NAME__, _version]
+    return cli_bump(bump_args)
 
 
 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")
     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
@@ -65,8 +97,8 @@ def main(args: list[str] | None = None) -> int:
         print(opts)
     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-0.9.0 → bear_utils-0.9.2}/src/bear_utils/_internal/debug.py

@@ -7,6 +7,8 @@ import os
 import platform
 import sys
 
+from bear_utils._internal._version import version as _version
+
 __PACKAGE_NAME__ = "bear-utils"
 
 
@@ -16,7 +18,7 @@ class _Package:
 
     name: str = __PACKAGE_NAME__
     """Package name."""
-    version: str = "0.0.0"
+    version: str = _version
     """Package version."""
     description: str = "No description available."
     """Package description."""
@@ -69,7 +71,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:

bear_utils-0.9.2/src/bear_utils/cli/_get_version.py

@@ -0,0 +1,206 @@
+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 RichStrEnum, StrValue as Value
+
+
+class VersionParts(RichStrEnum):
+    """Enumeration for version parts."""
+
+    MAJOR = Value("major", "Major version")
+    MINOR = Value("minor", "Minor version")
+    PATCH = Value("patch", "Patch version")
+
+    @classmethod
+    def choices(cls) -> list[str]:
+        """Return a list of valid version parts."""
+        return [version_part.value for version_part in cls]
+
+    @classmethod
+    def num(cls) -> int:
+        """Return the number of valid 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()
+
+
+class Version(BaseModel):
+    """Model to represent a version string."""
+
+    major: int
+    """Major version number."""
+    minor: int
+    """Minor version number."""
+    patch: int
+    """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.
+        """
+        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]))
+
+    @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 new_version(self, bump_type: Literal["major", "minor", "patch"]) -> Version:
+        """Return a new version string based on the bump type.
+
+        Args:
+            bump_type: The type of bump ("major", "minor", or "patch").
+
+        Returns:
+            A new version string.
+
+        Raises:
+            ValueError: If the bump_type is unsupported.
+        """
+        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}")
+        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 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 _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:]
+    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

{bear_utils-0.9.0 → bear_utils-0.9.2}/src/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-0.9.0 → bear_utils-0.9.2}/src/bear_utils/constants/_exit_code.py

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

{bear_utils-0.9.0 → bear_utils-0.9.2}/src/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-0.9.0 → bear_utils-0.9.2}/src/bear_utils/constants/_meta.py

@@ -1,22 +1,51 @@
 from dataclasses import dataclass
-from enum import IntEnum
+from enum import IntEnum, StrEnum
 from typing import Any, Self, TextIO
 
 
 @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
 
 
+@dataclass(frozen=True)
+class StrValue:
+    """A frozen dataclass for holding constant string values."""
+
+    value: str
+    text: str
+
+
+class RichStrEnum(StrEnum):
+    """Base class for StrEnums with rich metadata."""
+
+    text: 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
+        return obj
+
+    def __str__(self) -> str:
+        return f"{self.name} ({self.value}): {self.text}"
+
+    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
 
-    def __new__(cls, value: Value) -> Self:
+    def __new__(cls, value: IntValue) -> Self:
         _value: int = value.value
         text: str = value.text
         obj: Self = int.__new__(cls, _value)

{bear_utils-0.9.0 → bear_utils-0.9.2}/src/bear_utils/graphics/font/block_font.py

@@ -3,9 +3,7 @@
 from rich.align import Align
 from rich.console import Console
 
-from bear_utils.graphics.font._theme import CyberTheme as Theme
-
-from ._raw_block_letters import (
+from bear_utils.graphics.font._raw_block_letters import (
     ASTERISK,
     AT,
     BACKWARD_SLASH,
@@ -58,6 +56,7 @@ from ._raw_block_letters import (
     Y,
     Z,
 )
+from bear_utils.graphics.font._theme import CyberTheme as Theme
 
 BLOCK_LETTERS: dict[str, list[str]] = {
     "A": A,
@@ -121,7 +120,7 @@ def char_to_block(char: str) -> list[str]:
     return BLOCK_LETTERS.get(char.upper(), ["        "] * 5)
 
 
-def word_to_block(word: str) -> list[str]:
+def _word_to_block(word: str) -> list[str]:
     """Convert a word to its block font representation."""
     clean_text: str = "".join(char for char in word.upper() if char in BLOCK_LETTERS)
 
@@ -136,15 +135,25 @@ def word_to_block(word: str) -> list[str]:
     return rows
 
 
+def word_to_block(word: str) -> str:
+    """Convert a word to its block font representation as a single string."""
+    block_rows = _word_to_block(word)
+    return "\n".join(block_rows)
+
+
 def print_block_font(text: str, color: str = Theme.neon_green) -> None:
     """Print block font text with cyberpunk styling."""
-    block_rows = word_to_block(text)
+    block_rows = _word_to_block(text)
 
-    console.print()
     for row in block_rows:
         console.print(Align.center(f"[{color}]{row}[/{color}]"))
-    console.print()
 
 
 __all__ = ["BLOCK_LETTERS", "char_to_block", "word_to_block"]
 # fmt: on
+
+if __name__ == "__main__":
+    WORD = "BANKER"
+    BANKER = word_to_block(WORD)
+
+    console.print(Align.center(f"[{Theme.error}]{BANKER}[/{Theme.error}]"))

{bear_utils-0.9.0 → bear_utils-0.9.2}/src/bear_utils/logger_manager/_log_level.py

@@ -1,6 +1,6 @@
 from typing import Literal
 
-from bear_utils.constants._meta import RichIntEnum, Value
+from bear_utils.constants._meta import IntValue as Value, RichIntEnum
 
 FAILURE: Literal[45] = 45
 ERROR: Literal[40] = 40
@@ -13,6 +13,19 @@ VERBOSE: Literal[5] = 5
 NOTSET: Literal[0] = 0
 
 
+class LogLevel(RichIntEnum):
+    """Enumeration for logging levels."""
+
+    NOTSET = Value(NOTSET, "NOTSET")
+    VERBOSE = Value(VERBOSE, "VERBOSE")
+    DEBUG = Value(DEBUG, "DEBUG")
+    INFO = Value(INFO, "INFO")
+    WARNING = Value(WARNING, "WARNING")
+    ERROR = Value(ERROR, "ERROR")
+    FAILURE = Value(FAILURE, "FAILURE")
+    SUCCESS = Value(SUCCESS, "SUCCESS")
+
+
 level_to_name = {
     FAILURE: "FAILURE",
     ERROR: "ERROR",
@@ -35,16 +48,3 @@ name_to_level = {
     "VERBOSE": VERBOSE,
     "NOTSET": NOTSET,
 }
-
-
-class LogLevel(RichIntEnum):
-    """Enumeration for logging levels."""
-
-    NOTSET = Value(NOTSET, "NOTSET")
-    VERBOSE = Value(VERBOSE, "VERBOSE")
-    DEBUG = Value(DEBUG, "DEBUG")
-    INFO = Value(INFO, "INFO")
-    WARNING = Value(WARNING, "WARNING")
-    ERROR = Value(ERROR, "ERROR")
-    FAILURE = Value(FAILURE, "FAILURE")
-    SUCCESS = Value(SUCCESS, "SUCCESS")

bear_utils-0.9.0/.bumpversion.cfg

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