zabbix-cli-uio 3.1.1__py3-none-any.whl

zabbix_cli/__about__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+__version__ = "3.1.1"
+APP_NAME = "zabbix-cli"
+AUTHOR = "unioslo"

zabbix_cli/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from zabbix_cli._patches import patch_all
+
+patch_all()

zabbix_cli/__main__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from zabbix_cli.main import main
+
+if __name__ == "__main__":
+    main()

zabbix_cli/_patches/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from zabbix_cli._patches import typer
+
+
+def patch_all() -> None:
+    """Apply all patches to all modules."""
+    typer.patch()
+    # NOTE: we patch click_repl only when we actually launch the REPL
+    # See: zabbix_cli.main.start_repl

zabbix_cli/_patches/click_repl.py

@@ -0,0 +1,149 @@
+# type: ignore
+"""Patches for click_repl package."""
+
+from __future__ import annotations
+
+import shlex
+import sys
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Dict
+from typing import Optional
+
+import click
+import click_repl
+from click.exceptions import Exit as ClickExit
+from click_repl import ExitReplException
+from click_repl import bootstrap_prompt
+from click_repl import dispatch_repl_commands
+from click_repl import handle_internal_commands
+from prompt_toolkit.shortcuts import prompt
+
+from zabbix_cli._patches.common import get_patcher
+from zabbix_cli.exceptions import handle_exception
+
+if TYPE_CHECKING:
+    from click.core import Context
+
+    from zabbix_cli.app import StatefulApp
+
+patcher = get_patcher(f"click_repl version: {click_repl.__version__}")
+
+
+def repl(  # noqa: C901
+    old_ctx: Context,
+    prompt_kwargs: Dict[str, Any] = None,
+    allow_system_commands: bool = True,
+    allow_internal_commands: bool = True,
+    app: Optional[StatefulApp] = None,
+) -> None:
+    """Start an interactive shell. All subcommands are available in it.
+
+    :param old_ctx: The current Click context.
+    :param prompt_kwargs: Parameters passed to
+        :py:func:`prompt_toolkit.shortcuts.prompt`.
+
+    If stdin is not a TTY, no prompt will be printed, but only commands read
+    from stdin.
+    """
+    # parent should be available, but we're not going to bother if not
+    group_ctx = old_ctx.parent or old_ctx
+    group = group_ctx.command
+    isatty = sys.stdin.isatty()
+
+    # Delete the REPL command from those available, as we don't want to allow
+    # nesting REPLs (note: pass `None` to `pop` as we don't want to error if
+    # REPL command already not present for some reason).
+    repl_command_name = old_ctx.command.name
+    if isinstance(group_ctx.command, click.CommandCollection):
+        available_commands = {
+            cmd_name: cmd_obj
+            for source in group_ctx.command.sources
+            for cmd_name, cmd_obj in source.commands.items()
+        }
+    else:
+        available_commands = group_ctx.command.commands
+    available_commands.pop(repl_command_name, None)
+
+    prompt_kwargs = bootstrap_prompt(prompt_kwargs, group)
+
+    if isatty:
+
+        def get_command():
+            return prompt(**prompt_kwargs)
+
+    else:
+        get_command = sys.stdin.readline
+
+    while True:
+        try:
+            command = get_command()
+        except KeyboardInterrupt:
+            continue
+        except EOFError:
+            break
+
+        if not command:
+            if isatty:
+                continue
+            else:
+                break
+
+        if allow_system_commands and dispatch_repl_commands(command):
+            continue
+
+        if allow_internal_commands:
+            try:
+                result = handle_internal_commands(command)
+                if isinstance(result, str):
+                    click.echo(result)
+                    continue
+            except ExitReplException:
+                break
+
+        try:
+            args = shlex.split(command)
+        except ValueError as e:
+            click.echo(f"{type(e).__name__}: {e}")
+            continue
+
+        try:
+            if app:
+                group = app.as_click_group()
+            with group.make_context(None, args, parent=group_ctx) as ctx:
+                group.invoke(ctx)
+                ctx.exit()
+        except click.ClickException as e:
+            e.show()
+        except ClickExit:
+            pass
+        except SystemExit:
+            pass
+        except ExitReplException:
+            break
+        # PATCH: Handle zabbix-cli exceptions
+        except Exception as e:
+            try:
+                handle_exception(e)
+            except SystemExit:
+                pass
+        # PATCH: Continue on keyboard interrupt
+        except KeyboardInterrupt:
+            from zabbix_cli.output.console import err_console
+
+            # User likely pressed Ctrl+C during a prompt or when a spinner
+            # was active. Ensure message is printed on a new line.
+            # TODO: determine if last char in terminal was newline somehow! Can we?
+            err_console.print("\n[red]Aborted.[/]")
+            pass
+
+
+def patch_exception_handling() -> None:
+    """Patch click_repl's exception handling to fall back on zabbix-cli exception handlers."""
+    with patcher("click_repl.repl"):
+        click_repl.repl = repl
+
+
+def patch() -> None:
+    """Apply all patches."""
+    patch_exception_handling()

zabbix_cli/_patches/common.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from abc import ABC
+from abc import abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from types import TracebackType
+    from typing import Optional
+    from typing import Type
+
+
+class BasePatcher(ABC):
+    """Context manager that logs and prints diagnostic info if an exception
+    occurs.
+    """
+
+    def __init__(self, description: str) -> None:
+        self.description = description
+
+    @abstractmethod
+    def __package_info__(self) -> str:
+        raise NotImplementedError
+
+    def __enter__(self) -> BasePatcher:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> bool:
+        if not exc_type:
+            return True
+        import sys
+
+        import rich
+        from rich.table import Table
+
+        from zabbix_cli.__about__ import __version__
+
+        # Rudimentary, but provides enough info to debug and fix the issue
+        console = rich.console.Console(stderr=True)
+        console.print_exception()
+        console.print()
+        table = Table(
+            title="Diagnostics",
+            show_header=False,
+            show_lines=False,
+        )
+        table.add_row(
+            "[b]Package [/]",
+            self.__package_info__(),
+        )
+        table.add_row(
+            "[b]zabbix-cli [/]",
+            __version__,
+        )
+        table.add_row(
+            "[b]Python [/]",
+            sys.version,
+        )
+        table.add_row(
+            "[b]Platform [/]",
+            sys.platform,
+        )
+        console.print(table)
+        console.print(f"[bold red]ERROR: Failed to patch {self.description}[/]")
+        raise SystemExit(1)
+
+
+def get_patcher(info: str) -> Type[BasePatcher]:
+    """Returns a patcher for a given package."""
+
+    class Patcher(BasePatcher):
+        def __package_info__(self) -> str:
+            return info
+
+    return Patcher

zabbix_cli/_patches/typer.py

@@ -0,0 +1,317 @@
+# type: ignore
+"""Patching of Typer to extend functionality and change styling.
+
+Will probably break for some version of Typer at some point.
+"""
+
+from __future__ import annotations
+
+import inspect
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Callable
+from typing import Iterable
+from typing import Type
+from typing import Union
+from typing import cast
+from uuid import UUID
+
+import click
+import typer
+from typer.main import lenient_issubclass
+from typer.models import ParameterInfo
+
+from zabbix_cli._patches.common import get_patcher
+from zabbix_cli.pyzabbix.enums import APIStrEnum
+
+if TYPE_CHECKING:
+    from typing import Dict
+
+    from rich.style import Style
+
+patcher = get_patcher(f"Typer version: {typer.__version__}")
+
+
+def patch_help_text_style() -> None:
+    """Remove dimming of help text.
+
+    https://github.com/tiangolo/typer/issues/437#issuecomment-1224149402
+    """
+    with patcher("typer.rich_utils.STYLE_HELPTEXT"):
+        typer.rich_utils.STYLE_HELPTEXT = ""
+
+
+def patch_help_text_spacing() -> None:
+    """Adds a single blank line between short and long help text of a command when using `--help`.
+
+    As of Typer 0.9.0, the short and long help text is printed without any
+    blank lines between them. This is bad for readability (IMO).
+    """
+    from rich.console import group
+    from rich.markdown import Markdown
+    from rich.text import Text
+    from typer.rich_utils import DEPRECATED_STRING
+    from typer.rich_utils import MARKUP_MODE_MARKDOWN
+    from typer.rich_utils import MARKUP_MODE_RICH
+    from typer.rich_utils import STYLE_DEPRECATED
+    from typer.rich_utils import STYLE_HELPTEXT
+    from typer.rich_utils import STYLE_HELPTEXT_FIRST_LINE
+    from typer.rich_utils import MarkupMode
+    from typer.rich_utils import _make_rich_rext
+
+    @group()
+    def _get_help_text(
+        *,
+        obj: Union[click.Command, click.Group],
+        markup_mode: MarkupMode,
+    ) -> Iterable[Union[Markdown, Text]]:
+        """Build primary help text for a click command or group.
+
+        Returns the prose help text for a command or group, rendered either as a
+        Rich Text object or as Markdown.
+        If the command is marked as deprecated, the deprecated string will be prepended.
+        """
+        # Prepend deprecated status
+        if obj.deprecated:
+            yield Text(DEPRECATED_STRING, style=STYLE_DEPRECATED)
+
+        # Fetch and dedent the help text
+        help_text = inspect.cleandoc(obj.help or "")
+
+        # Trim off anything that comes after \f on its own line
+        help_text = help_text.partition("\f")[0]
+
+        # Get the first paragraph
+        first_line = help_text.split("\n\n")[0]
+        # Remove single linebreaks
+        if markup_mode != MARKUP_MODE_MARKDOWN and not first_line.startswith("\b"):
+            first_line = first_line.replace("\n", " ")
+        yield _make_rich_rext(
+            text=first_line.strip(),
+            style=STYLE_HELPTEXT_FIRST_LINE,
+            markup_mode=markup_mode,
+        )
+
+        # Get remaining lines, remove single line breaks and format as dim
+        remaining_paragraphs = help_text.split("\n\n")[1:]
+        if remaining_paragraphs:
+            if markup_mode != MARKUP_MODE_RICH:
+                # Remove single linebreaks
+                remaining_paragraphs = [
+                    x.replace("\n", " ").strip()
+                    if not x.startswith("\b")
+                    else "{}\n".format(x.strip("\b\n"))
+                    for x in remaining_paragraphs
+                ]
+                # Join back together
+                remaining_lines = "\n".join(remaining_paragraphs)
+            else:
+                # Join with double linebreaks if markdown
+                remaining_lines = "\n\n".join(remaining_paragraphs)
+            yield _make_rich_rext(
+                text="\n",
+                style=STYLE_HELPTEXT,
+                markup_mode=markup_mode,
+            )
+            yield _make_rich_rext(
+                text=remaining_lines,
+                style=STYLE_HELPTEXT,
+                markup_mode=markup_mode,
+            )
+
+    with patcher("typer.rich_utils._get_help_text"):
+        typer.rich_utils._get_help_text = _get_help_text
+
+
+def patch_generate_enum_convertor() -> None:
+    """Patches enum value converter with an additional fallback to
+    instantiating the enum with the value directly.
+    """
+
+    def generate_enum_convertor(enum: Type[Enum]) -> Callable[[Any], Any]:
+        lower_val_map = {str(val.value).lower(): val for val in enum}
+
+        def convertor(value: Any) -> Any:
+            if value is not None:
+                low = str(value).lower()
+                if low in lower_val_map:
+                    key = lower_val_map[low]
+                    return enum(key)
+                # Fall back to passing in the value as-is
+                try:
+                    return enum(value)
+                except ValueError:
+                    return None
+
+        return convertor
+
+    with patcher("typer.main.generate_enum_convertor"):
+        typer.main.generate_enum_convertor = generate_enum_convertor
+
+
+def patch_get_click_type() -> None:
+    """Adds support for our custom `APIStrEnum` type.
+
+    Used in conjunction with our custom generate_enum_convertor to support
+    instantiating `APIStrEnum` with both the human-readable value and the API value
+    (e.g. `"Enabled"` and `0`).
+
+    Uses the `APIStrEnum.all_choices()` method to get the list of choices.
+    """
+
+    def get_click_type(
+        *, annotation: Any, parameter_info: ParameterInfo
+    ) -> click.ParamType:
+        if parameter_info.click_type is not None:
+            return parameter_info.click_type
+
+        elif parameter_info.parser is not None:
+            return click.types.FuncParamType(parameter_info.parser)
+
+        elif annotation == str:  # noqa: E721
+            return click.STRING
+        elif annotation == int:  # noqa: E721
+            if parameter_info.min is not None or parameter_info.max is not None:
+                min_ = None
+                max_ = None
+                if parameter_info.min is not None:
+                    min_ = int(parameter_info.min)
+                if parameter_info.max is not None:
+                    max_ = int(parameter_info.max)
+                return click.IntRange(min=min_, max=max_, clamp=parameter_info.clamp)
+            else:
+                return click.INT
+        elif annotation == float:  # noqa: E721
+            if parameter_info.min is not None or parameter_info.max is not None:
+                return click.FloatRange(
+                    min=parameter_info.min,
+                    max=parameter_info.max,
+                    clamp=parameter_info.clamp,
+                )
+            else:
+                return click.FLOAT
+        elif annotation == bool:  # noqa: E721
+            return click.BOOL
+        elif annotation == UUID:
+            return click.UUID
+        elif annotation == datetime:
+            return click.DateTime(formats=parameter_info.formats)
+        elif (
+            annotation == Path
+            or parameter_info.allow_dash
+            or parameter_info.path_type
+            or parameter_info.resolve_path
+        ):
+            return click.Path(
+                exists=parameter_info.exists,
+                file_okay=parameter_info.file_okay,
+                dir_okay=parameter_info.dir_okay,
+                writable=parameter_info.writable,
+                readable=parameter_info.readable,
+                resolve_path=parameter_info.resolve_path,
+                allow_dash=parameter_info.allow_dash,
+                path_type=parameter_info.path_type,
+            )
+        elif lenient_issubclass(annotation, typer.FileTextWrite):
+            return click.File(
+                mode=parameter_info.mode or "w",
+                encoding=parameter_info.encoding,
+                errors=parameter_info.errors,
+                lazy=parameter_info.lazy,
+                atomic=parameter_info.atomic,
+            )
+        elif lenient_issubclass(annotation, typer.FileText):
+            return click.File(
+                mode=parameter_info.mode or "r",
+                encoding=parameter_info.encoding,
+                errors=parameter_info.errors,
+                lazy=parameter_info.lazy,
+                atomic=parameter_info.atomic,
+            )
+        elif lenient_issubclass(annotation, typer.FileBinaryRead):
+            return click.File(
+                mode=parameter_info.mode or "rb",
+                encoding=parameter_info.encoding,
+                errors=parameter_info.errors,
+                lazy=parameter_info.lazy,
+                atomic=parameter_info.atomic,
+            )
+        elif lenient_issubclass(annotation, typer.FileBinaryWrite):
+            return click.File(
+                mode=parameter_info.mode or "wb",
+                encoding=parameter_info.encoding,
+                errors=parameter_info.errors,
+                lazy=parameter_info.lazy,
+                atomic=parameter_info.atomic,
+            )
+        # our patch for APIStrEnum
+        elif lenient_issubclass(annotation, APIStrEnum):
+            annotation = cast(Type[APIStrEnum], annotation)
+            return click.Choice(
+                annotation.all_choices(),
+                case_sensitive=parameter_info.case_sensitive,
+            )
+        elif lenient_issubclass(annotation, Enum):
+            return click.Choice(
+                [item.value for item in annotation],
+                case_sensitive=parameter_info.case_sensitive,
+            )
+        raise RuntimeError(f"Type not yet supported: {annotation}")  # pragma no cover
+
+    """Patch typer's get_click_type to support more types."""
+    with patcher("typer.main.get_click_type"):
+        typer.main.get_click_type = get_click_type
+
+
+def patch__get_rich_console() -> None:
+    from rich.console import Console
+    from typer.rich_utils import COLOR_SYSTEM
+    from typer.rich_utils import FORCE_TERMINAL
+    from typer.rich_utils import MAX_WIDTH
+    from typer.rich_utils import STYLE_METAVAR
+    from typer.rich_utils import STYLE_METAVAR_SEPARATOR
+    from typer.rich_utils import STYLE_NEGATIVE_OPTION
+    from typer.rich_utils import STYLE_NEGATIVE_SWITCH
+    from typer.rich_utils import STYLE_OPTION
+    from typer.rich_utils import STYLE_SWITCH
+    from typer.rich_utils import STYLE_USAGE
+    from typer.rich_utils import highlighter
+
+    from zabbix_cli.output.style import RICH_THEME
+
+    theme: Dict[str, Union[str, Style]] = RICH_THEME.styles.copy()  # type: ignore[assignment]
+    theme.update(
+        {
+            "option": STYLE_OPTION,
+            "switch": STYLE_SWITCH,
+            "negative_option": STYLE_NEGATIVE_OPTION,
+            "negative_switch": STYLE_NEGATIVE_SWITCH,
+            "metavar": STYLE_METAVAR,
+            "metavar_sep": STYLE_METAVAR_SEPARATOR,
+            "usage": STYLE_USAGE,
+        },
+    )
+
+    def _get_rich_console(stderr: bool = False) -> Console:
+        return Console(
+            theme=RICH_THEME,
+            highlighter=highlighter,
+            color_system=COLOR_SYSTEM,
+            force_terminal=FORCE_TERMINAL,
+            width=MAX_WIDTH,
+            stderr=stderr,
+        )
+
+    typer.rich_utils._get_rich_console = _get_rich_console
+
+
+def patch() -> None:
+    """Apply all patches."""
+    patch_help_text_style()
+    patch_help_text_spacing()
+    patch_generate_enum_convertor()
+    patch_get_click_type()
+    patch__get_rich_console()

zabbix_cli/_types.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import sys
+
+if sys.version_info >= (3, 10):
+    from types import EllipsisType
+
+    EllipsisType = EllipsisType
+else:
+    from typing import Any
+
+    EllipsisType = Any

zabbix_cli/_v2_compat.py

@@ -0,0 +1,102 @@
+"""Compatibility functions going from Zabbix-CLI v2 to v3.
+
+The functions in this module are intended to ease the transition by
+providing fallbacks to deprecated functionality in Zabbix-CLI v2.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+from typing import List
+from typing import Optional
+
+import typer
+
+if TYPE_CHECKING:
+    from click.core import CommandCollection
+    from click.core import Group
+
+
+CONFIG_FILENAME = "zabbix-cli.conf"
+CONFIG_FIXED_NAME = "zabbix-cli.fixed.conf"
+
+# Config file locations
+CONFIG_DEFAULT_DIR = "/usr/share/zabbix-cli"
+CONFIG_SYSTEM_DIR = "/etc/zabbix-cli"
+CONFIG_USER_DIR = os.path.expanduser("~/.zabbix-cli")
+
+# Any item will overwrite values from the previous (NYI)
+CONFIG_PRIORITY = tuple(
+    Path(os.path.join(d, f))
+    for d, f in (
+        (CONFIG_DEFAULT_DIR, CONFIG_FIXED_NAME),
+        (CONFIG_SYSTEM_DIR, CONFIG_FIXED_NAME),
+        (CONFIG_USER_DIR, CONFIG_FILENAME),
+        (CONFIG_SYSTEM_DIR, CONFIG_FILENAME),
+        (CONFIG_DEFAULT_DIR, CONFIG_FILENAME),
+    )
+)
+
+
+AUTH_FILE = Path.home() / ".zabbix-cli_auth"
+AUTH_TOKEN_FILE = Path.home() / ".zabbix-cli_auth_token"
+
+
+def run_command_from_option(ctx: typer.Context, command: str) -> None:
+    """Runs a command via old-style --command/-C option."""
+    from zabbix_cli.output.console import error
+    from zabbix_cli.output.console import exit_err
+    from zabbix_cli.output.console import warning
+
+    warning(
+        "The [i]--command/-C[/] option is deprecated and will be removed in a future release. "
+        "Invoke command directly instead."
+    )
+    if not isinstance(ctx.command, (CommandCollection, Group)):
+        exit_err(  # TODO: find out if this could ever happen?
+            f"Cannot run command {command!r}. Ensure it is a valid command and try again."
+        )
+    cmd_obj = ctx.command.get_command(ctx, command)
+    if not cmd_obj:
+        exit_err(
+            f"Cannot run command {command!r}. Ensure it is a valid command and try again."
+        )
+    try:
+        ctx.invoke(cmd_obj, *ctx.args)
+    except typer.Exit:
+        pass
+    except Exception as e:
+        error(
+            f"Command {command!r} failed with error: {e}. Try re-running without --command."
+        )
+
+
+def args_callback(
+    ctx: typer.Context, value: Optional[List[str]]
+) -> Optional[List[str]]:
+    if ctx.resilient_parsing:
+        return  # for auto-completion
+    if value:
+        from zabbix_cli.output.console import warning
+
+        warning(
+            f"Detected deprecated positional arguments {value}. Use options instead."
+        )
+    # NOTE: Must NEVER return None. The "fix" in Typer 0.10.0 for None defaults
+    # somehow broke the parsing of callback values by causing values returned by
+    # callbacks to be passed to the internal converter, which then fails
+    # because it expects a list but gets None.
+    # https://github.com/tiangolo/typer/pull/664
+    # https://github.com/tiangolo/typer/blob/142422a14ca4c6a8ad579e9bd0fd0728364d86e3/typer/main.py#L639
+    return value or []
+
+
+ARGS_POSITIONAL = typer.Argument(
+    None,
+    help="DEPRECATED: V2-style positional arguments.",
+    show_default=False,
+    hidden=True,
+    callback=args_callback,
+)