midpoint-cli 1.6.0__py3-none-any.whl

midpoint_cli/prompt/delete.py

@@ -0,0 +1,89 @@
+import shlex
+import sys
+from argparse import ArgumentParser, RawTextHelpFormatter
+
+from midpoint_cli.client import MidpointObjectType, MidpointObjectTypes, MidpointServerError
+from midpoint_cli.client.objects import MidpointTypeNotFound
+from midpoint_cli.prompt.base import PromptBase
+from midpoint_cli.prompt.complete import OBJECT_OF_TYPE, OBJECT_TYPE, completes
+from midpoint_cli.prompt.console import print_info
+
+delete_parser = ArgumentParser(
+    formatter_class=RawTextHelpFormatter,
+    prog='delete',
+    description='Delete a server object by OID or name.',
+    epilog='A name must designate a single object: when several objects have it, their OIDs are listed\n'
+    'and nothing is deleted. Deleting by name asks for confirmation, or needs --yes when not run\n'
+    'from a terminal.',
+)
+completes(delete_parser.add_argument('objectclass', help='Type of the object to delete (Java Type).'), OBJECT_TYPE)
+completes(delete_parser.add_argument('oid', metavar='OID_OR_NAME', help='Object ID, or object name.'), OBJECT_OF_TYPE)
+delete_parser.add_argument(
+    '-y', '--yes', action='store_true', help='Delete an object given by name without asking for confirmation.'
+)
+
+
+class DeleteClientPrompt(PromptBase):
+    parser_delete = parser_del = parser_rm = delete_parser
+
+    def do_rm(self, inp: str) -> None:
+        """Alias for delete."""
+        self.do_delete(inp)
+
+    def do_del(self, inp: str) -> None:
+        """Alias for delete."""
+        self.do_delete(inp)
+
+    def do_delete(self, inp: str) -> None:
+        """Delete a server object by type and OID or name."""
+        try:
+            delete_args = shlex.split(inp)
+            ns = delete_parser.parse_args(delete_args)
+
+            # Resolve the type string to a MidpointObjectType
+            midpoint_type = MidpointObjectTypes.find_by_name(ns.objectclass)
+
+            if midpoint_type.endpoint is None:
+                self._fail(f'{ns.objectclass} cannot be deleted through the REST API')
+                return
+
+            oid = self.client.resolve_oid(midpoint_type, ns.oid)
+
+            # A name is a weaker reference than an OID: make sure the resolved object is the intended one.
+            if oid != ns.oid and not ns.yes and not self._confirm_delete(midpoint_type, ns.oid, oid):
+                return
+
+            self.client.delete(midpoint_type, oid)
+
+        except (MidpointTypeNotFound, MidpointServerError, AttributeError) as e:
+            self._fail(str(e))
+
+    def _confirm_delete(self, midpoint_type: MidpointObjectType, name: str, oid: str) -> bool:
+        """Ask before deleting an object designated by name; refuse when nobody can answer."""
+        if not (hasattr(sys.stdin, 'isatty') and sys.stdin.isatty()):
+            self._fail(
+                f'{name!r} is a name, not an OID: add --yes to delete {midpoint_type.tagname} {oid} '
+                f'without confirmation'
+            )
+            return False
+
+        # The question is a message, so it goes to stderr: input() would write it on stdout.
+        sys.stderr.write(f"Delete {midpoint_type.tagname} '{name}' ({oid})? [y/N] ")
+        sys.stderr.flush()
+        try:
+            answer = input()
+        except EOFError:
+            answer = ''
+        if answer.strip().lower() in ('y', 'yes'):
+            return True
+        print_info('Deletion cancelled')
+        return False
+
+    def help_delete(self) -> None:
+        delete_parser.print_help()
+
+    def help_rm(self) -> None:
+        delete_parser.print_help()
+
+    def help_del(self) -> None:
+        delete_parser.print_help()

midpoint_cli/prompt/get.py

@@ -0,0 +1,66 @@
+import shlex
+from argparse import ArgumentParser, RawTextHelpFormatter
+from xml.etree import ElementTree
+
+from midpoint_cli.client import MidpointObjectTypes, MidpointServerError
+from midpoint_cli.client.constants import ResultStatus
+from midpoint_cli.client.objects import MidpointTypeNotFound, namespaces
+from midpoint_cli.client.patch import write_private_file
+from midpoint_cli.client.safe_xml import fromstring as safe_fromstring
+from midpoint_cli.prompt.base import PromptBase
+from midpoint_cli.prompt.complete import FILE, OBJECT_OF_TYPE, OBJECT_TYPE, completes
+from midpoint_cli.prompt.console import print_xml
+
+get_parser = ArgumentParser(
+    formatter_class=RawTextHelpFormatter,
+    prog='get',
+    description='Get a server object by OID or name.',
+    epilog='A name must designate a single object: when several objects have it, their OIDs are listed\n'
+    'and nothing is fetched.',
+)
+completes(get_parser.add_argument('objectclass', help='Type of the object to fetch (Java Type).'), OBJECT_TYPE)
+completes(get_parser.add_argument('oid', metavar='OID_OR_NAME', help='Object ID, or object name.'), OBJECT_OF_TYPE)
+completes(get_parser.add_argument('file', help='Save the XML data to this file.', nargs='?'), FILE)
+
+
+class GetClientPrompt(PromptBase):
+    parser_get = get_parser
+
+    def do_get(self, inp: str) -> None:
+        """Get an XML definition from the server by type and OID or name."""
+        try:
+            get_args = shlex.split(inp)
+            ns = get_parser.parse_args(get_args)
+
+            midpoint_type = MidpointObjectTypes.find_by_name(ns.objectclass)
+
+            if midpoint_type.endpoint is None:
+                self._fail(f'{ns.objectclass} cannot be fetched through the REST API')
+                return
+
+            oid = self.client.resolve_oid(midpoint_type, ns.oid)
+            xml_text = self.client.get_xml(midpoint_type, oid)
+            xml_root = safe_fromstring(xml_text)
+
+            status_node = xml_root.find('c:status', namespaces)
+
+            if status_node is not None and status_node.text == ResultStatus.FATAL_ERROR:
+                message_node = xml_root.find('c:message', namespaces)
+                self._fail((message_node.text if message_node is not None else None) or 'Unknown error')
+            elif ns.file is None:
+                print_xml(xml_text)
+            else:
+                # The file is created with mode 0600 and never through a symbolic link:
+                # object XML can hold PII and protected-string or hash material.
+                try:
+                    write_private_file(ns.file, xml_text)
+                except OSError as e:
+                    self._fail(f'Cannot write {ns.file}: {e.strerror or e}')
+
+        except (MidpointTypeNotFound, MidpointServerError, AttributeError) as e:
+            self._fail(str(e))
+        except ElementTree.ParseError as e:
+            self._fail(f'Server returned a malformed XML document: {e}')
+
+    def help_get(self) -> None:
+        get_parser.print_help()

midpoint_cli/prompt/info.py

@@ -0,0 +1,53 @@
+from midpoint_cli.prompt.base import PromptBase
+from midpoint_cli.prompt.console import (
+    create_table,
+    get_console,
+    is_machine_output,
+    print_info,
+    print_rows,
+    print_warning,
+)
+
+INFO_COLUMNS = ('Property', 'Value')
+
+
+class InfoClientPrompt(PromptBase):
+    def do_info(self, inp: str) -> None:
+        """Display server information (version, repository, subscription, nodes, account)."""
+        # Printed before calling the server, so a failing call still shows which server,
+        # account and timeouts were used, and where each setting came from.
+        if self.configuration is not None:
+            print_info(self.configuration.describe())
+        try:
+            server_info = self.client.get_server_information()
+        except Exception as e:
+            self._fail(f'Could not retrieve server information: {e}')
+            return
+
+        for problem in server_info.unavailable:
+            print_warning(f'Not shown, could not read {problem}')
+
+        if is_machine_output():
+            rows = [dict(zip(INFO_COLUMNS, item, strict=True)) for item in server_info.properties.items()]
+            print_rows(rows, title='Server Information', noun='properties', columns=INFO_COLUMNS)
+            return
+
+        if not server_info.properties:
+            print_info('No server information available')
+            return
+
+        table = create_table(title='Server Information')
+        table.add_column('Property', style='bright_cyan')
+        table.add_column('Value', style='white')
+        for key, value in server_info.properties.items():
+            table.add_row(key, value)
+        get_console().print(table)
+
+    def help_info(self) -> None:
+        print(
+            'Display server information: Midpoint version and build, repository, subscription,\n'
+            'deployment name, cluster nodes and the account in use. Sources the account may not\n'
+            'read are left out with a warning. The first line names the server URL, user and\n'
+            'timeouts in use and where each setting came from. Honours -o: json, csv and tsv\n'
+            'print Property/Value rows.'
+        )

midpoint_cli/prompt/log.py

@@ -0,0 +1,98 @@
+import shlex
+from argparse import ArgumentParser, RawTextHelpFormatter
+
+from midpoint_cli.client import MidpointServerError
+from midpoint_cli.client.logging_config import LOGGING_LEVELS
+from midpoint_cli.prompt.base import PromptBase
+from midpoint_cli.prompt.console import is_machine_output, print_info, print_rows, print_success
+
+log_parser = ArgumentParser(
+    formatter_class=RawTextHelpFormatter,
+    prog='log',
+    description='Show and set the logger levels of the server (system configuration, logging section).',
+    epilog=f"""
+Available commands:
+  ls     List the class loggers and their levels.
+  set    Set the level of a logger: log set LOGGER LEVEL. The logger is added
+         when it is not configured yet.
+
+Short form of set: log LOGGER LEVEL, e.g. log com.evolveum.midpoint.model DEBUG
+(use "log set" for a logger named ls or set).
+LEVEL is one of {', '.join(LOGGING_LEVELS)} (any case).
+The change is saved in the system configuration and Midpoint applies it at once.
+""",
+)
+
+log_ls_parser = ArgumentParser(
+    formatter_class=RawTextHelpFormatter,
+    prog='log ls',
+    description='List the class loggers of the system configuration with their level and appenders.\n'
+    'The root logger level is printed after the table.',
+)
+
+log_set_parser = ArgumentParser(
+    formatter_class=RawTextHelpFormatter,
+    prog='log set',
+    description='Set the level of a class logger, adding the logger when it is not configured yet.\n'
+    'Only the logging section of the system configuration is modified.',
+)
+log_set_parser.add_argument('logger', help='Logger name: a package or class, e.g. com.evolveum.midpoint.model.')
+log_set_parser.add_argument(
+    'level', type=str.upper, choices=LOGGING_LEVELS, help='Logging level, case-insensitive: %(choices)s.'
+)
+
+# Each subcommand with its parser; None for those taking no arguments.
+log_subparsers: dict[str, ArgumentParser | None] = {'ls': log_ls_parser, 'set': log_set_parser}
+
+LOG_COLUMNS = ('Logger', 'Level', 'Appenders')
+
+
+class LogClientPrompt(PromptBase):
+    subparsers_log = log_subparsers
+
+    def do_log(self, inp: str) -> None:
+        """Show and set server logger levels (subcommands: ls, set; or: log LOGGER LEVEL)."""
+        try:
+            log_args = shlex.split(inp)
+            if self._subcommand_help(log_args, log_subparsers):
+                return
+            if not log_args or log_args[0] in ('-h', '--help'):
+                log_parser.print_help()
+                self.error_code = 0 if log_args else 1
+                return
+
+            if log_args[0] == 'ls':
+                log_ls_parser.parse_args(log_args[1:])
+                self._list_loggers()
+            elif log_args[0] == 'set':
+                ns = log_set_parser.parse_args(log_args[1:])
+                self._set_logger(ns.logger, ns.level)
+            else:
+                # Short form: log LOGGER LEVEL
+                ns = log_set_parser.parse_args(log_args)
+                self._set_logger(ns.logger, ns.level)
+        except (MidpointServerError, ValueError) as e:
+            self._fail(str(e))
+
+    def _list_loggers(self) -> None:
+        configuration = self.client.get_logging_configuration()
+        rows = [
+            dict(zip(LOG_COLUMNS, (logger.package, logger.level or '', ', '.join(logger.appenders)), strict=True))
+            for logger in configuration.class_loggers
+        ]
+        print_rows(rows, title='Class Loggers', noun='class loggers', columns=LOG_COLUMNS)
+        # Machine formats write data only, so the root level is a table-mode note.
+        if not is_machine_output():
+            print_info(f'Root logger level: {configuration.root_level or "(not set)"}')
+
+    def _set_logger(self, logger: str, level: str) -> None:
+        outcome = self.client.set_class_logger(logger, level)
+        if outcome == 'unchanged':
+            print_info(f'Logger {logger} is already at level {level}')
+        elif outcome == 'added':
+            print_success(f'Logger {logger} added at level {level}')
+        else:
+            print_success(f'Logger {logger} set to level {level}')
+
+    def help_log(self) -> None:
+        log_parser.print_help()

midpoint_cli/prompt/org.py

@@ -0,0 +1,122 @@
+import contextlib
+from argparse import ArgumentParser, RawTextHelpFormatter
+
+# Org command wrapper parser
+from midpoint_cli.client import MidpointClient, MidpointObjectList, MidpointObjectTypes, MidpointServerError
+from midpoint_cli.prompt.base import PromptBase, add_listing_arguments, print_object_detail
+from midpoint_cli.prompt.complete import ORG, completes
+from midpoint_cli.prompt.console import print_rows
+
+org_parser = ArgumentParser(
+    formatter_class=RawTextHelpFormatter,
+    prog='org',
+    description='Manage server organizations.',
+    epilog="""
+Available commands:
+  ls       List all organizations.
+  search   Search for an organization.
+  get      Get organization details by OID or name.
+""",
+)
+org_parser.add_argument('command', help='Organization command to execute.')
+org_parser.add_argument('arg', help='Optional command arguments.', nargs='*')
+
+org_ls_parser = add_listing_arguments(
+    ArgumentParser(
+        formatter_class=RawTextHelpFormatter,
+        prog='org ls',
+        description='List organizations.',
+    ),
+    'organizations',
+)
+
+org_search = ArgumentParser(
+    formatter_class=RawTextHelpFormatter,
+    prog='org search',
+    description='Search for organizations by substring of their name or display name, ignoring case.\n'
+    'Terms are combined with OR. Prefix a term with + to make it mandatory (AND).',
+)
+org_search.add_argument(
+    'searchquery',
+    help='String fragments to search for. Use +term to require a match (AND); plain terms are optional (OR).',
+    nargs='+',
+)
+
+org_get_parser = ArgumentParser(
+    formatter_class=RawTextHelpFormatter,
+    prog='org get',
+    description='Get organization details by OID or name.',
+)
+completes(org_get_parser.add_argument('oid', help='An organization OID or name.'), ORG)
+
+# Each subcommand with its parser; None for those taking no arguments.
+org_subparsers: dict[str, ArgumentParser | None] = {'ls': org_ls_parser, 'search': org_search, 'get': org_get_parser}
+
+
+def _enrich_parent_names(orgs: MidpointObjectList, client: MidpointClient) -> None:
+    """Show each parent as 'OID / name', fetching the parents missing from orgs in one search."""
+    known = {org['OID']: org for org in orgs}
+    missing = sorted({org['Parent'] for org in orgs if org.get('Parent') and org['Parent'] not in known})
+    if missing:
+        with contextlib.suppress(MidpointServerError):  # Parent names are cosmetic: show the bare OIDs.
+            known.update({org['OID']: org for org in client.get_orgs_by_oid(missing)})
+    lookup = {oid: org.get('DisplayName') or org.get('Name', '') for oid, org in known.items()}
+    for org in orgs:
+        parent_oid = org.get('Parent')
+        if parent_oid:
+            parent_name = lookup.get(parent_oid, '')
+            org['Parent'] = f'{parent_oid} / {parent_name}' if parent_name else parent_oid
+
+
+class OrgClientPrompt(PromptBase):
+    subparsers_org = org_subparsers
+
+    def do_org(self, inp: str) -> None:
+        """Manage organizations (subcommands: ls, search, get)."""
+        self._dispatch_subcommand(
+            inp,
+            org_parser,
+            org_subparsers,
+            {'ls': self._org_ls, 'search': self._org_search, 'get': self._org_get},
+        )
+
+    def _org_ls(self, args: list[str]) -> None:
+        ls_ns = org_ls_parser.parse_args(args)
+        orgs = self.client.get_orgs(limit=ls_ns.limit, name_filter=ls_ns.filter)
+        _enrich_parent_names(orgs, self.client)
+        self._print_orgs_table(orgs)
+
+    def _org_search(self, args: list[str]) -> None:
+        search_ns = org_search.parse_args(args)
+        orgs = self.client.search_orgs(search_ns.searchquery)
+        _enrich_parent_names(orgs, self.client)
+        self._print_orgs_table(orgs)
+
+    def _org_get(self, args: list[str]) -> None:
+        get_ns = org_get_parser.parse_args(args)
+        oid = self.client.resolve_oid(MidpointObjectTypes.ORG.value, get_ns.oid)
+        org = self.client.get_org(oid)
+        parent_oid = org.get('Parent')
+        if parent_oid:
+            try:
+                parent = self.client.get_org(parent_oid)
+                parent_name = parent.get('DisplayName') or parent.get('Name', '')
+                org['Parent'] = f'{parent_oid} / {parent_name}' if parent_name else parent_oid
+            except MidpointServerError:
+                pass
+        print_object_detail(org, 'Organization Details')
+
+    def help_org(self) -> None:
+        org_parser.print_help()
+
+    def do_orgs(self, inp: str) -> None:
+        """Shortcut for 'org ls' — list all organizations."""
+        self._list_shortcut(inp, 'orgs', 'org', self.do_org)
+
+    def help_orgs(self) -> None:
+        print('List all server organizations. This is a shortcut for "org ls"')
+
+    @staticmethod
+    def _print_orgs_table(orgs: MidpointObjectList) -> None:
+        """Print organizations in the selected output format."""
+        print_rows(orgs, title='Organizations', noun='organizations')

midpoint_cli/prompt/output.py

@@ -0,0 +1,33 @@
+"""`output` command: show or change the output format for the rest of the session."""
+
+import shlex
+from argparse import ArgumentParser, RawTextHelpFormatter
+
+from midpoint_cli.prompt.base import PromptBase
+from midpoint_cli.prompt.console import OUTPUT_FORMATS, get_output_format, print_info, set_output_format
+
+output_parser = ArgumentParser(
+    formatter_class=RawTextHelpFormatter,
+    prog='output',
+    description='Show or change the output format of list and detail commands for the rest of the session.',
+    epilog='Without a format, the current one is shown. The format starts as the -o/--output option\n'
+    'selects (by default table on a terminal, tsv when the output is redirected or piped).',
+)
+output_parser.add_argument('format', nargs='?', choices=OUTPUT_FORMATS, help='The new output format: %(choices)s.')
+
+
+class OutputClientPrompt(PromptBase):
+    parser_output = output_parser
+
+    def do_output(self, inp: str) -> None:
+        """Show or change the output format of this session (table, json, csv, tsv)."""
+        ns = output_parser.parse_args(shlex.split(inp))
+        if ns.format is None:
+            print_info(f'Output format: {get_output_format()}')
+        else:
+            set_output_format(ns.format)
+            print_info(f'Output format set to {ns.format}')
+
+    @staticmethod
+    def help_output() -> None:
+        output_parser.print_help()

midpoint_cli/prompt/put.py

@@ -0,0 +1,71 @@
+import shlex
+from argparse import ArgumentParser, RawTextHelpFormatter
+from xml.etree import ElementTree
+
+from midpoint_cli.client import MidpointServerError, MidpointUnsupportedOperation
+from midpoint_cli.client.objects import MidpointTypeNotFound
+from midpoint_cli.client.patch import PatchError
+from midpoint_cli.prompt.base import PromptBase
+from midpoint_cli.prompt.complete import FILE, completes
+from midpoint_cli.prompt.console import print_success
+
+put_parser = ArgumentParser(
+    formatter_class=RawTextHelpFormatter,
+    prog='put',
+    description='Create or update a server object.',
+    epilog='A root element with an oid attribute creates or replaces the object at that OID.\n'
+    'Without one, a new object is created and the server assigns its OID.',
+)
+completes(
+    put_parser.add_argument(
+        '-p', '--patch', help='Patch the object according to the following patch file.', action='store'
+    ),
+    FILE,
+)
+put_parser.add_argument(
+    '-w', '--patchwrite', help='Write the result of the patching phase in a file <patchfile>.xml', action='store_true'
+)
+completes(put_parser.add_argument('file', nargs='+', help='Load XML data from this file (one or more).'), FILE)
+
+
+class PutClientPrompt(PromptBase):
+    parser_put = put_parser
+
+    def do_put(self, inp: str) -> None:
+        """Create or update a server object from an XML file."""
+        # Parsed outside the upload loop so an argparse SystemExit is not mistaken
+        # for a failed file; onecmd turns it into the exit code.
+        put_args = shlex.split(inp)
+        ns = put_parser.parse_args(put_args)
+
+        for f in ns.file:
+            try:
+                result = self.client.put_xml(f, ns.patch, ns.patchwrite)
+                if not result.created:
+                    print_success(f'Object uploaded: {result.object_type.object_type} {result.oid}')
+                elif result.oid is not None:
+                    print_success(f'Object created: {result.object_type.object_type} {result.oid}')
+                else:
+                    print_success(
+                        f'Object accepted: {result.object_type.object_type} '
+                        '(the server reported no OID; creation may be pending approval)'
+                    )
+            except (MidpointServerError, MidpointUnsupportedOperation, MidpointTypeNotFound) as e:
+                self._fail_put(f, str(e))
+                return
+            except ElementTree.ParseError as e:
+                self._fail_put(f, f'not a well-formed XML document ({e})')
+                return
+            except PatchError as e:
+                self._fail_put(f, str(e))
+                return
+            except OSError as e:
+                self._fail_put(f, str(e.strerror or e))
+                return
+
+    def _fail_put(self, filename: str, reason: str) -> None:
+        """Stop the upload run, reporting which file failed and why."""
+        self._fail(f'{filename}: {reason}')
+
+    def help_put(self) -> None:
+        put_parser.print_help()

midpoint_cli/prompt/report.py

@@ -0,0 +1,69 @@
+from argparse import ArgumentParser, RawTextHelpFormatter
+
+from midpoint_cli.client import MidpointObjectTypes
+from midpoint_cli.prompt.base import PromptBase, add_listing_arguments, add_new_task_arguments
+from midpoint_cli.prompt.complete import REPORT, completes
+from midpoint_cli.prompt.console import print_rows
+
+report_parser = ArgumentParser(
+    formatter_class=RawTextHelpFormatter,
+    prog='report',
+    description='List and run reports.',
+    epilog="""
+Available commands:
+  ls     List reports.
+  run    Run a report (creates and runs a report export task).
+""",
+)
+report_parser.add_argument('command', help='Report command to execute.')
+report_parser.add_argument('arg', help='Optional command arguments.', nargs='*')
+
+report_ls_parser = add_listing_arguments(
+    ArgumentParser(
+        formatter_class=RawTextHelpFormatter,
+        prog='report ls',
+        description='List reports.',
+    ),
+    'reports',
+)
+
+report_run_parser = add_new_task_arguments(
+    ArgumentParser(
+        formatter_class=RawTextHelpFormatter,
+        prog='report run',
+        description='Run a report: create a report export task and run it.',
+        epilog='The server stores the output as a report data object, which the Midpoint GUI lists\n'
+        'under Reports > Created reports.',
+    )
+)
+completes(report_run_parser.add_argument('report', help='Report OID or name.'), REPORT)
+
+# Each subcommand with its parser; None for those taking no arguments.
+report_subparsers: dict[str, ArgumentParser | None] = {'ls': report_ls_parser, 'run': report_run_parser}
+
+
+class ReportClientPrompt(PromptBase):
+    subparsers_report = report_subparsers
+
+    def do_report(self, inp: str) -> None:
+        """List and run reports (subcommands: ls, run)."""
+        self._dispatch_subcommand(
+            inp, report_parser, report_subparsers, {'ls': self._report_ls, 'run': self._report_run}
+        )
+
+    def _report_ls(self, args: list[str]) -> None:
+        ls_ns = report_ls_parser.parse_args(args)
+        reports = self.client.get_reports(limit=ls_ns.limit, name_filter=ls_ns.filter)
+        print_rows(reports, title='Reports', noun='reports')
+
+    def _report_run(self, args: list[str]) -> None:
+        run_ns = report_run_parser.parse_args(args)
+        report = self._require_object(MidpointObjectTypes.REPORT.value, run_ns.report, 'Report')
+        if report is None:
+            return
+        task_oid, task_name = self.client.start_report_task(report)
+        self._follow_new_task(task_oid, task_name, run_ns.no_wait, show_changes=not run_ns.no_changes)
+
+    @staticmethod
+    def help_report() -> None:
+        report_parser.print_help()