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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.9.0
+Version: 0.9.3
 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
@@ -25,7 +26,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.3}/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.3}/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.3/maskfile.md

@@ -0,0 +1,84 @@
+# 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
+uv sync
+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"
+    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=$(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}"
+```
+
+## 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}" = "twine" ]; 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.9.0 → bear_utils-0.9.3}/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"
@@ -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,8 +31,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]
@@ -51,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 = [
@@ -77,7 +81,8 @@ filterwarnings = [
 ]
 
 [tool.pyright]
-include = ["src"]
+include = ["src", "tests"]
+testpaths = ["tests"]
 exclude = ["**/__pycache__"]
 venvPath = "."
 venv = ".venv"
@@ -85,3 +90,18 @@ 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
+format = "{base}"
+
+[tool.hatch.build.hooks.version]
+path = "src/bear_utils/_internal/_version.py"
+template = '''
+version = "{version}"
+'''

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

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

bear_utils-0.9.3/src/bear_utils/_internal/cli.py

@@ -0,0 +1,119 @@
+# Why does this file exist, and why not put this in `__main__`?
+#
+# You might be tempted to import things from `__main__` later,
+# but that will cause problems: the code will get executed twice:
+#
+# - When you run `python -m bear_utils` python will execute
+#   `__main__.py` as a script. That means there won't be any
+#   `bear_utils.__main__` in `sys.modules`.
+# - When you import `__main__` it will get executed again (as a module) because
+#   there's no `bear_utils.__main__` in `sys.modules`.
+from __future__ import annotations
+
+from argparse import Action, ArgumentParser, Namespace
+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):
+    def __init__(self, nargs: int | str | None = 0, **kwargs: Any) -> None:
+        super().__init__(nargs=nargs, **kwargs)
+
+    def __call__(self, *_: Any, **__: Any) -> None:
+        debug._print_debug_info()
+        sys.exit(ExitCode.SUCCESS)
+
+
+class _About(Action):
+    def __init__(self, nargs: int | str | None = 0, **kwargs: Any) -> None:
+        super().__init__(nargs=nargs, **kwargs)
+
+    def __call__(self, *_: Any, **__: Any) -> None:
+        print(debug._get_package_info())
+        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 = 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) -> ExitCode:
+    """Main entry point for the CLI.
+
+    This function is called when the CLI is executed. It can be used to
+    initialize the CLI, parse arguments, and execute commands.
+
+    Args:
+        args (list[str] | None): A list of command-line arguments. If None, uses sys.argv[1:].
+
+    Returns:
+        int: Exit code of the CLI execution. 0 for success, non-zero for failure.
+    """
+    if args is None:
+        args = sys.argv[1:]
+    try:
+        parser: ArgumentParser = get_parser()
+        opts: Namespace = parser.parse_args(args)
+        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
+    return ExitCode.SUCCESS
+
+
+if __name__ == "__main__":
+    main()

{bear_utils-0.9.0 → bear_utils-0.9.3}/src/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-0.9.3/src/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-0.9.0 → bear_utils-0.9.3}/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.3}/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 IntValue as Value, RichIntEnum
 
 
 class ExitCode(RichIntEnum):

{bear_utils-0.9.0 → bear_utils-0.9.3}/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):