funcy-bear 0.0.2__py3-none-any.whl

funcy_bear/__init__.py

@@ -0,0 +1,7 @@
+"""Funcy Bear: A collection of functional programming utilities."""
+
+from funcy_bear._internal.cli import METADATA, main
+
+__version__: str = METADATA.version
+
+__all__: list[str] = ["METADATA", "__version__", "main"]

funcy_bear/__main__.py

@@ -0,0 +1,14 @@
+"""Entry-point module, in case you use `python -m funcy_bear`.
+
+Why does this file exist, and why `__main__`? For more info, read:
+
+- https://www.python.org/dev/peps/pep-0338/
+- https://docs.python.org/3/using/cmdline.html#cmdoption-m
+"""
+
+import sys
+
+from funcy_bear._internal.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

funcy_bear/_internal/_info.py

@@ -0,0 +1,169 @@
+from dataclasses import dataclass, field
+from importlib.metadata import PackageNotFoundError, distribution, version
+from typing import Literal
+
+from funcy_bear._internal._version import __commit_id__, __version__, __version_tuple__
+
+
+@dataclass(slots=True)
+class _Package:
+    """Dataclass to store package information."""
+
+    name: str
+    """Package name."""
+    version: str = "0.0.0"
+    """Package version."""
+    description: str = "No description available."
+    """Package description."""
+
+    def __str__(self) -> str:
+        """String representation of the package information."""
+        return f"{self.name} v{self.version}: {self.description}"
+
+
+def _get_package_info(dist: str) -> _Package:
+    """Get package information for the given distribution.
+
+    Parameters:
+        dist: A distribution name.
+
+    Returns:
+        Package information with version, name, and description.
+    """
+    return _Package(name=dist, version=_get_version(dist), description=_get_description(dist))
+
+
+def _get_version(dist: str = "funcy-bear") -> str:
+    """Get version of the given distribution or the current package.
+
+    Parameters:
+        dist: A distribution name.
+
+    Returns:
+        A version number.
+    """
+    try:
+        return version(dist)
+    except PackageNotFoundError:
+        return "0.0.0"
+
+
+def _get_description(dist: str = "funcy-bear") -> str:
+    """Get description of the given distribution or the current package.
+
+    Parameters:
+        dist: A distribution name.
+
+    Returns:
+        A description string.
+    """
+    try:
+        return distribution(dist).metadata.get("summary", "No description available.")
+    except PackageNotFoundError:
+        return "No description available."
+
+
+# fmt: off
+@dataclass(slots=True, frozen=True)
+class _ProjectName:
+    """A class to represent the project name and its metadata as literals for type safety.
+
+    This is done this way to make it easier to see the values in the IDE and to ensure that the values are consistent throughout the codebase.
+    """
+
+    package_distribution: Literal["funcy-bear"] = "funcy-bear"
+    project: Literal["funcy_bear"] = "funcy_bear"
+    project_upper: Literal["FUNCY_BEAR"] = "FUNCY_BEAR"
+    env_variable: Literal["FUNCY_BEAR_ENV"] = ("FUNCY_BEAR_ENV")
+# fmt: on
+
+
+@dataclass(slots=True, frozen=True)
+class _ProjectVersion:
+    """A class to represent the project version."""
+
+    string: str
+    ver_tuple: tuple[int, int, int] = field(default=__version_tuple__)
+    commit_id: str = field(default=__commit_id__)
+
+
+@dataclass(slots=True, frozen=True)
+class _ModulePaths:
+    """A class to hold the module import paths, mostly for the CLI."""
+
+    _internal: str = "funcy_bear._internal"
+    _commands: str = f"{_internal}._cmds"
+
+
+@dataclass(slots=True)
+class _ProjectMetadata:
+    """Dataclass to store the current project metadata."""
+
+    _version: _ProjectVersion
+    _name: _ProjectName = field(default_factory=_ProjectName)
+    _paths: _ModulePaths = field(default_factory=_ModulePaths)
+
+    def __str__(self) -> str:
+        """String representation of the project metadata."""
+        return f"{self.full_version}: {self.description}"
+
+    @property
+    def cmds(self) -> str:
+        """Get the commands module path."""
+        return self._paths._commands
+
+    @property
+    def version(self) -> str:
+        """Get the project version as a string."""
+        return self._version.string
+
+    @property
+    def version_tuple(self) -> tuple[int, int, int]:
+        """Get the project version as a tuple."""
+        return self._version.ver_tuple
+
+    @property
+    def commit_id(self) -> str:
+        """Get the Git commit ID of the current version."""
+        return self._version.commit_id
+
+    @property
+    def full_version(self) -> str:
+        """Get the full version string."""
+        return f"{self.name} v{self._version.string}"
+
+    @property
+    def description(self) -> str:
+        """Get the project description from the distribution metadata."""
+        return _get_description(self.name)
+
+    @property
+    def name(self) -> Literal["funcy-bear"]:
+        """Get the package distribution name."""
+        return self._name.package_distribution
+
+    @property
+    def name_upper(self) -> Literal["FUNCY_BEAR"]:
+        """Get the project name in uppercase with underscores."""
+        return self._name.project_upper
+
+    @property
+    def project_name(self) -> Literal["funcy_bear"]:
+        """Get the project name."""
+        return self._name.project
+
+    @property
+    def env_variable(self) -> Literal["FUNCY_BEAR_ENV"]:
+        """Get the environment variable name for the project.
+
+        Used to check if the project is running in a specific environment.
+        """
+        return self._name.env_variable
+
+
+_version = _ProjectVersion(string=__version__ if __version__ != "0.0.0" else _get_version())
+
+METADATA = _ProjectMetadata(_version=_version)
+
+
+__all__ = ["METADATA", "_Package"]

funcy_bear/_internal/_version.py

@@ -0,0 +1,3 @@
+__version__ = "0.0.1"
+__commit_id__ = ""
+__version_tuple__ = (0, 0, 1)

funcy_bear/_internal/_version.pyi

@@ -0,0 +1,6 @@
+__version__: str
+"""The version of the package."""
+__commit_id__: str
+"""The git commit ID of the current version."""
+__version_tuple__: tuple[int, int, int]
+"""The version of the package as a tuple."""

funcy_bear/_internal/_versioning.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import IntEnum
+from typing import Literal
+
+from funcy_bear.constants.exit_code import ExitCode
+
+type BumpType = Literal["major", "minor", "patch"]
+
+
+class VersionParts(IntEnum):  # pragma: no cover
+    """Enumeration for version parts."""
+
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 2
+
+    @classmethod
+    def choices(cls) -> list[str]:
+        """Return a list of valid version parts."""
+        return [part.name.lower() for part in cls]
+
+    @classmethod
+    def parts(cls) -> int:
+        """Return the total number of version parts."""
+        return len(cls.choices())
+
+
+@dataclass(slots=True)
+class Version:  # pragma: no cover
+    """Model to represent a version string."""
+
+    major: int = field(default=0)
+    minor: int = field(default=0)
+    patch: int = field(default=0)
+    post: str | None = field(default=None)
+
+    def increment(self, attr_name: str) -> None:
+        """Increment the specified part of the version."""
+        if hasattr(self, attr_name.lower()):
+            current_value: int = getattr(self, attr_name.lower())
+            setattr(self, attr_name.lower(), current_value + 1)
+
+    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: VersionParts = VersionParts[bump_type.upper()]
+        self.increment(bump_part.name)
+        for part in VersionParts:
+            if part.value > bump_part.value:
+                self.default(part.name)
+        return self
+
+    def __repr__(self) -> str:
+        """Return a string representation of the Version instance."""
+        return (
+            f"{self.major}.{self.minor}.{self.patch}.{self.post}"
+            if self.post
+            else f"{self.major}.{self.minor}.{self.patch}"
+        )
+
+    def __str__(self) -> str:
+        """Return a string representation of the Version instance."""
+        return self.__repr__()
+
+
+VALID_BUMP_TYPES: list[str] = VersionParts.choices()  # pragma: no cover
+ALL_PARTS: int = VersionParts.parts()  # pragma: no cover
+
+
+def cli_bump(b: BumpType, v: str | tuple[int, int, int]) -> ExitCode:  # pragma: no cover
+    """Bump the version of the current package.
+
+    Args:
+        b: The type of bump ("major", "minor", or "patch").
+        p: The name of the package.
+        v: The current version string or tuple of version parts.
+
+    Returns:
+        An ExitCode indicating success or failure.
+    """
+    if b not in VALID_BUMP_TYPES:
+        print(f"Invalid argument '{b}'. Use one of: {', '.join(VALID_BUMP_TYPES)}.")
+        return ExitCode.FAILURE
+    if not isinstance(v, tuple):
+        raise TypeError("Version must be a tuple of integers.")
+    try:
+        parts: list[int] = list(v)
+        version: Version = Version(
+            major=parts[0],
+            minor=parts[1] if ALL_PARTS > 1 else 0,
+            patch=parts[2] if ALL_PARTS > 2 else 0,  # noqa: PLR2004
+        )
+        new_version: Version = version.new_version(b)
+        print(str(new_version))
+        return ExitCode.SUCCESS
+    except ValueError:
+        print(f"Invalid version tuple: {v}")
+        return ExitCode.FAILURE
+
+
+__all__ = ["Version", "VersionParts"]

funcy_bear/_internal/cli.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from argparse import ArgumentParser, Namespace
+import sys
+
+from funcy_bear._internal._versioning import BumpType, ExitCode, cli_bump
+from funcy_bear._internal.debug import METADATA, _print_debug_info
+from funcy_bear.context.arg_helpers import args_inject
+
+
+def _debug_info() -> ExitCode:  # pragma: no cover
+    """CLI command to print debug information."""
+    _print_debug_info()
+    return ExitCode.SUCCESS
+
+
+def _bump(bump_type: BumpType) -> ExitCode:  # pragma: no cover
+    """CLI command to bump the version of the package."""
+    return cli_bump(bump_type, METADATA.version_tuple)
+
+
+def _version(name: bool = False) -> ExitCode:  # pragma: no cover
+    """CLI command to get the current version of the package."""
+    print(f"{METADATA.name} {METADATA.version}" if name else METADATA.version)
+    return ExitCode.SUCCESS
+
+
+def _to_args(args: list[str]) -> Namespace:  # pragma: no cover
+    """Convert a list of arguments into a Namespace object."""
+    parser = ArgumentParser(prog=METADATA.name, description="Lazy Bear CLI")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    subparsers.add_parser("debug-info", help="Print debug information")
+    version_parser: ArgumentParser = subparsers.add_parser("version", help="Get the current version")
+    version_parser.add_argument("--name", action="store_true", help="Include the package name in the output")
+    bump_parser: ArgumentParser = subparsers.add_parser("bump", help="Bump the version of the package")
+    bump_parser.add_argument("bump_type", choices=["major", "minor", "patch"], help="Type of version bump")
+    return parser.parse_args(args)
+
+
+@args_inject(process=_to_args)
+def main(args: Namespace) -> ExitCode:
+    """Entry point for the CLI application.
+
+    This function is executed when you type `lazy_bear` or `python -m lazy_bear`.
+
+    Parameters:
+        args: Arguments passed from the command line.
+
+    Returns:
+        An exit code.
+    """
+    command: str = args.command
+    match command:
+        case "debug-info":
+            return _debug_info()
+        case "version":
+            return _version(name=args.name)
+        case "bump":
+            return _bump(bump_type=args.bump_type)
+        case _:  # pragma: no cover
+            print(f"Unknown command: {command}", file=sys.stderr)
+            return ExitCode.FAILURE
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

funcy_bear/_internal/debug.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib.metadata import distributions
+from os import environ, getenv
+import platform
+import sys
+
+from funcy_bear._internal._info import METADATA, _get_package_info, _Package
+
+
+@dataclass
+class _Variable:
+    """Dataclass describing an environment variable."""
+
+    name: str
+    """Variable name."""
+    value: str
+    """Variable value."""
+
+
+@dataclass
+class _Environment:
+    """Dataclass to store environment information."""
+
+    interpreter_name: str
+    """Python interpreter name."""
+    interpreter_version: str
+    """Python interpreter version."""
+    interpreter_path: str
+    """Path to Python executable."""
+    platform: str
+    """Operating System."""
+    packages: list[_Package]
+    """Installed packages."""
+    variables: list[_Variable]
+    """Environment variables."""
+
+
+def _interpreter_name_version() -> tuple[str, str]:
+    if hasattr(sys, "implementation"):
+        impl: sys._version_info = sys.implementation.version
+        version: str = f"{impl.major}.{impl.minor}.{impl.micro}"
+        kind = impl.releaselevel
+        if kind != "final":
+            version += kind[0] + str(impl.serial)
+        return sys.implementation.name, version
+    return "", "0.0.0"
+
+
+def _get_debug_info() -> _Environment:
+    """Get debug/environment information.
+
+    Returns:
+        Environment information.
+    """
+    py_name, py_version = _interpreter_name_version()
+    environ[f"{METADATA.name_upper}_DEBUG"] = "1"
+    variables: list[str] = ["PYTHONPATH", *[var for var in environ if var.startswith(METADATA.name_upper)]]
+    return _Environment(
+        interpreter_name=py_name,
+        interpreter_version=py_version,
+        interpreter_path=sys.executable,
+        platform=platform.platform(),
+        variables=[_Variable(var, val) for var in variables if (val := getenv(var))],
+        packages=_get_installed_packages(),
+    )
+
+
+def _get_installed_packages() -> list[_Package]:
+    """Get all installed packages in current environment"""
+    packages: list[_Package] = []
+    for dist in distributions():
+        packages.append(_get_package_info(dist.metadata["Name"]))
+    return packages
+
+
+def _print_debug_info() -> None:
+    """Print debug/environment information with minimal clean formatting."""
+    info: _Environment = _get_debug_info()
+    sections: list[tuple[str, list[tuple[str, str]]]] = [
+        (
+            "SYSTEM",
+            [
+                ("Platform", info.platform),
+                ("Python", f"{info.interpreter_name} {info.interpreter_version}"),
+                ("Location", info.interpreter_path),
+            ],
+        ),
+        ("ENVIRONMENT", [(var.name, var.value) for var in info.variables]),
+        ("PACKAGES", [(pkg.name, f"v{pkg.version}") for pkg in info.packages]),
+    ]
+
+    for i, (section_name, items) in enumerate(sections):
+        if items:
+            print(f"{section_name}")
+            for key, value in items:
+                print(key, end=": ")
+                print(value)
+            if i != len(sections) - 1:
+                print()
+
+
+if __name__ == "__main__":
+    _print_debug_info()

funcy_bear/api.py

@@ -0,0 +1,70 @@
+"""Funcy Bear: A collection of functional programming utilities."""
+
+from funcy_bear.ops.collections_ops.dict_stuffs import key_counts, merge as merge_dicts
+from funcy_bear.ops.collections_ops.iter_stuffs import merge, merge_lists, merge_sets, merge_tuples, pairwise, window
+from funcy_bear.ops.curried_ops import (
+    abs,  # noqa: A004
+    add,
+    append,
+    clamp,
+    decrement,
+    default,
+    delete,
+    div,
+    extend,
+    format,  # noqa: A004
+    if_else,
+    increment,
+    lower,
+    mod,
+    multiply,
+    pop,
+    pow,  # noqa: A004
+    prepend,
+    push,
+    replace,
+    setter,
+    subtract,
+    toggle,
+    upper,
+)
+from funcy_bear.ops.func_stuffs import if_in_list
+from funcy_bear.type_stuffs.constants import LitFalse, LitTrue
+
+__all__ = [
+    "LitFalse",
+    "LitTrue",
+    "abs",
+    "add",
+    "append",
+    "clamp",
+    "decrement",
+    "default",
+    "delete",
+    "div",
+    "extend",
+    "format",
+    "if_else",
+    "if_in_list",
+    "increment",
+    "key_counts",
+    "lower",
+    "merge",
+    "merge_dicts",
+    "merge_lists",
+    "merge_sets",
+    "merge_tuples",
+    "mod",
+    "multiply",
+    "pairwise",
+    "pop",
+    "pow",
+    "prepend",
+    "push",
+    "replace",
+    "setter",
+    "subtract",
+    "toggle",
+    "upper",
+    "window",
+]

funcy_bear/constants/__init__.py

@@ -0,0 +1,69 @@
+"""A set of helpful constants used throughout the Bear Dereth and beyond!"""
+
+from pathlib import Path
+
+from .exit_code import ExitCode
+from .file_size import (
+    FILE_SIZES,
+    GIGABYTES,
+    KILOBYTES,
+    MEGABYTES,
+    TERABYTES,
+    Gigabytes,
+    Kilobytes,
+    Megabytes,
+    Terabytes,
+)
+
+
+def get_config_path() -> Path:
+    """Get the path to the configuration directory based on the operating system."""
+    import os  # noqa: PLC0415
+
+    if "XDG_CONFIG_HOME" in os.environ:
+        return Path(os.environ["XDG_CONFIG_HOME"])
+    if "APPDATA" in os.environ:
+        return Path(os.environ["APPDATA"])
+    return Path.home() / ".config"
+
+
+PATH_TO_DOWNLOADS: Path = Path.home() / "Downloads"
+"""Path to the Downloads folder."""
+PATH_TO_PICTURES: Path = Path.home() / "Pictures"
+"""Path to the Pictures folder."""
+PATH_TO_DOCUMENTS: Path = Path.home() / "Documents"
+"""Path to the Documents folder."""
+PATH_TO_HOME: Path = Path.home()
+"""Path to the user's home directory."""
+PATH_TO_CONFIG: Path = get_config_path()
+"""Path to the configuration directory based on the operating system."""
+
+
+VIDEO_EXTS: list[str] = [".mp4", ".mov", ".avi", ".mkv"]
+"""Extensions for video files."""
+IMAGE_EXTS: list[str] = [".jpg", ".jpeg", ".png", ".gif", ".webp"]
+"""Extensions for image files."""
+FILE_EXTS: list[str] = IMAGE_EXTS + VIDEO_EXTS
+"""Extensions for both image and video files."""
+
+
+__all__ = [
+    "FILE_EXTS",
+    "FILE_SIZES",
+    "GIGABYTES",
+    "IMAGE_EXTS",
+    "KILOBYTES",
+    "MEGABYTES",
+    "PATH_TO_CONFIG",
+    "PATH_TO_DOCUMENTS",
+    "PATH_TO_DOWNLOADS",
+    "PATH_TO_HOME",
+    "PATH_TO_PICTURES",
+    "TERABYTES",
+    "VIDEO_EXTS",
+    "ExitCode",
+    "Gigabytes",
+    "Kilobytes",
+    "Megabytes",
+    "Terabytes",
+]