pyinfra 0.11.dev3__py3-none-any.whl → 3.6__py3-none-any.whl

pyinfra_cli/commands.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import json
+
+from pyinfra.api.facts import FactBase
+
+from .exceptions import CliError
+from .util import parse_cli_arg, try_import_module_attribute
+
+
+def get_func_and_args(commands):
+    operation_name = commands[0]
+
+    op = try_import_module_attribute(operation_name, prefix="pyinfra.operations")
+
+    # Parse the arguments
+    operation_args = commands[1:]
+
+    if len(operation_args) == 1:
+        # Check if we're JSON (in which case we expect a list of two items:
+        # a list of args and a dict of kwargs).
+        try:
+            args, kwargs = json.loads(operation_args[0])
+            return op, (args or (), kwargs or {})
+        except ValueError:
+            pass
+
+    args = [parse_cli_arg(arg) for arg in operation_args if "=" not in arg]
+
+    kwargs = {
+        key: parse_cli_arg(value)
+        for key, value in [arg.split("=", 1) for arg in operation_args if "=" in arg]
+    }
+
+    return op, (args, kwargs)
+
+
+def get_facts_and_args(commands):
+    facts: list[tuple[FactBase, tuple, dict]] = []
+
+    current_fact = None
+
+    for command in commands:
+        if "=" in command:
+            if not current_fact:
+                raise CliError("Invalid fact commands: `{0}`".format(commands))
+
+            key, value = command.split("=", 1)
+            current_fact[2][key] = parse_cli_arg(value)
+            continue
+
+        if current_fact:
+            facts.append(current_fact)
+            current_fact = None
+
+        if "." not in command:
+            raise CliError(f"Invalid fact: `{command}`, should be in the format `module.cls`")
+
+        fact_cls = try_import_module_attribute(command, prefix="pyinfra.facts")
+        assert fact_cls is not None
+        current_fact = (fact_cls, (), {})
+
+    if current_fact:
+        facts.append(current_fact)
+
+    return facts

pyinfra_cli/exceptions.py

@@ -1,78 +1,168 @@
+import abc
 import sys
-
-from traceback import format_exception, format_tb
+from inspect import getframeinfo
+from traceback import format_exception, format_tb, walk_tb
+from types import TracebackType
 
 import click
-
-from pyinfra import logger, pseudo_host, pseudo_state
-from pyinfra.api.exceptions import PyinfraError
-from pyinfra.hook import Error as HookError
-
-
-class CliError(PyinfraError, click.ClickException):
-    def show(self):
-        name = 'unknown error'
-
-        if isinstance(self, HookError):
-            name = 'hook error'
-
-        elif isinstance(self, PyinfraError):
-            name = 'pyinfra error'
-
-        elif isinstance(self, IOError):
-            name = 'local IO error'
-
-        if pseudo_host.isset():
-            # Get any operation meta + name
-            op_name = None
-            current_op_hash = pseudo_state.current_op_hash
-            current_op_meta = pseudo_state.op_meta.get(current_op_hash)
-            if current_op_meta:
-                op_name = ', '.join(current_op_meta['names'])
-
-            sys.stderr.write('--> {0}{1}{2}: '.format(
-                pseudo_host.print_prefix,
-                click.style(name, 'red', bold=True),
-                ' (operation={0})'.format(op_name) if op_name else '',
-            ))
-        else:
-            sys.stderr.write(
-                '--> {0}: '.format(click.style(name, 'red', bold=True)),
-            )
-
-        logger.warning(self)
-
-
-class UnexpectedError(click.ClickException):
+from typing_extensions import override
+
+from pyinfra import logger
+from pyinfra.api.exceptions import (
+    ArgumentTypeError,
+    ConnectorDataTypeError,
+    OperationError,
+    PyinfraError,
+)
+from pyinfra.api.util import PYINFRA_INSTALL_DIR
+
+
+def get_frame_line_from_tb(tb: TracebackType):
+    frame_lines = list(walk_tb(tb))
+    frame_lines.reverse()
+    for frame, line in frame_lines:
+        info = getframeinfo(frame)
+        if info.filename.startswith(PYINFRA_INSTALL_DIR):
+            continue
+        return info
+
+
+class WrappedError(click.ClickException):
+    def __init__(self, e: Exception):
+        self.traceback = e.__traceback__
+        self.exception = e
+
+        # Pull message from the wrapped exception
+        message = getattr(e, "message", e.args[0])
+        if not isinstance(message, str):
+            message = repr(message)
+        self.message = message
+
+    @override
+    def show(self, file=None):
+        name = "unknown error"
+
+        if isinstance(self.exception, ConnectorDataTypeError):
+            name = "Connector data type error"
+        elif isinstance(self.exception, ArgumentTypeError):
+            name = "Argument type error"
+        elif isinstance(self.exception, OperationError):
+            name = "Operation error"
+        elif isinstance(self.exception, PyinfraError):
+            name = "pyinfra error"
+        elif isinstance(self.exception, IOError):
+            name = "Local IO error"
+
+        if self.traceback:
+            info = get_frame_line_from_tb(self.traceback)
+            if info:
+                name = f"{name} in {info.filename} line {info.lineno}"
+
+        logger.warning(
+            "--> {0}: {1}".format(
+                click.style(name, "red", bold=True),
+                self,
+            ),
+        )
+
+
+class CliError(click.ClickException):
+    @override
+    def show(self, file=None):
+        logger.warning(
+            "--> {0}: {1}".format(
+                click.style("pyinfra error", "red", bold=True),
+                self,
+            ),
+        )
+
+
+class UnexpectedMixin(abc.ABC):
+    exception: Exception
+    traceback: TracebackType
+
+    def get_traceback_lines(self):
+        traceback = getattr(self.exception, "_traceback")
+        return format_tb(traceback)
+
+    def get_traceback(self):
+        return "".join(self.get_traceback_lines())
+
+    def get_exception(self):
+        return "".join(format_exception(self.exception.__class__, self.exception, None))
+
+
+class UnexpectedExternalError(click.ClickException, UnexpectedMixin):
+    def __init__(self, e, filename):
+        _, _, traceback = sys.exc_info()
+        e._traceback = traceback
+        self.exception = e
+        self.filename = filename
+
+    @override
+    def show(self, file=None):
+        logger.warning(
+            "--> {0}:\n".format(
+                click.style(
+                    "An exception occurred in: {0}".format(self.filename),
+                    "red",
+                    bold=True,
+                ),
+            ),
+        )
+
+        click.echo("Traceback (most recent call last):", err=True)
+        click.echo(self.get_traceback(), err=True, nl=False)
+        click.echo(self.get_exception(), err=True)
+
+
+class UnexpectedInternalError(click.ClickException, UnexpectedMixin):
     def __init__(self, e):
-        self.e = e
-
-    def show(self):
-        sys.stderr.write('--> {0}:\n'.format(click.style(
-            'An unexpected exception occurred',
-            'red',
-            bold=True,
-        )))
-        print()
-
-        traceback = getattr(self.e, '_traceback')
-        traceback_lines = format_tb(traceback)
-        traceback = ''.join(traceback_lines)
+        _, _, traceback = sys.exc_info()
+        e._traceback = traceback
+        self.exception = e
+
+    @override
+    def show(self, file=None):
+        click.echo(
+            "--> {0}:\n".format(
+                click.style(
+                    "An internal exception occurred",
+                    "red",
+                    bold=True,
+                ),
+            ),
+            err=True,
+        )
+
+        traceback_lines = self.get_traceback_lines()
+        traceback = self.get_traceback()
 
         # Syntax errors contain the filename/line/etc, but other exceptions
         # don't, so print the *last* call to stderr.
-        if not isinstance(self.e, SyntaxError):
+        if not isinstance(self.exception, SyntaxError):
             sys.stderr.write(traceback_lines[-1])
 
-        exception = ''.join(format_exception(self.e.__class__, self.e, None))
-        sys.stderr.write(exception)
+        exception = self.get_exception()
+        click.echo(exception, err=True)
 
-        # Write the full trace + exception to pyinfra-debug.log
-        with open('pyinfra-debug.log', 'w') as f:
+        with open("pyinfra-debug.log", "w", encoding="utf-8") as f:
             f.write(traceback)
             f.write(exception)
 
-        print()
-        print('--> The full traceback has been written to {0}'.format(
-            click.style('pyinfra-debug.log', bold=True),
-        ))
+        logger.debug(traceback)
+        logger.debug(exception)
+
+        click.echo(
+            "--> The full traceback has been written to {0}".format(
+                click.style("pyinfra-debug.log", bold=True),
+            ),
+            err=True,
+        )
+        click.echo(
+            (
+                "--> If this is unexpected please consider submitting a bug report "
+                "on GitHub, for more information run `pyinfra --support`."
+            ),
+            err=True,
+        )