3810345645

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #18 from cisagov/improvement/complete-no-ssh

Run Details

16 of 113 branches covered (14.16%)

Branch coverage included in aggregate %.

1 of 4 new or added lines in 2 files covered. (25.0%)

57 existing lines in 1 file now uncovered.

59 of 239 relevant lines covered (24.69%)

0.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/awssh/autocompleter.py

"""AWS SSH autocompleter script."""

# Standard Python Libraries
import configparser
from dataclasses import dataclass
import os
from pathlib import Path
import re
import shlex
from typing import Optional, TextIO

# Third-Party Libraries
import boto3

from . import CREDENTIAL_DIR, DEFAULT_CREDENTIAL_FILE

CREDENTIALS_OPTIONS = {"--credentials", "-c"}
HELP_OPTIONS = {"--help", "-h"}
LOG_LEVEL_OPTIONS = {"--log-level"}
LOG_LEVELS = {"debug", "info", "warning", "error", "critical"}
NO_SSH_OPTIONS = {"--no-ssh", "-n"}
REGION_OPTIONS = {"--region", "-r"}
SSH_ARGS_OPTIONS = {"--ssh-args", "-s"}

if os.environ.get("LC_CTYPE", "") == "UTF-8":
    os.environ["LC_CTYPE"] = "en_US.UTF-8"

# Debugging the completer can be touchy since standard out goes to bash.
# Set the environment below to a filename to enable logging.
LOG_FILE: Optional[TextIO] = None
if filename := os.environ.get("BASH_COMP_DEBUG_FILE"):
    LOG_FILE = open(filename, "a", encoding="utf-8")


def log(message: str) -> None:
    """Log a message to the log file if it is open.

    Args:
        message (str): The message to log.
    """
    if LOG_FILE:
        print(message, file=LOG_FILE)


def get_cred_files() -> set[str]:
    """Return a set of all credential files in the credential directory.

    Returns:
        set[str]: A set of all credential files in the credential directory.
    """
    result: set[str] = set()
    for i in CREDENTIAL_DIR.iterdir():
        if i.is_file():
            result.add(i.name)
    return result


def get_regions() -> set[str]:
    """Return a set of all available AWS regions.

    Returns:
        set[str]: A set of all available AWS regions.
    """
    session = boto3.session.Session(region_name="us-east-1")
    return set(session.get_available_regions("ec2"))


def get_profiles(cred_filename: Path, profile_filter: Optional[str] = None) -> set[str]:
    """Return a set of profiles within a credential file that match the filter.

    Args:
        cred_filename (Path): The path to the credential file.
        profile_filter (Optional[str], optional): Regular expression to match profile names. Defaults to None.

    Returns:
        set[str]: A set of profiles within a credential file that match the filter.
    """
    if profile_filter:
        profile_filter_re: re.Pattern[str] = re.compile(profile_filter)
    config = configparser.ConfigParser()
    config.read(cred_filename)
    result: set[str] = set()
    for section in config.sections():
        if not profile_filter_re or profile_filter_re.search(section):
            result.add(section)
    return result


def get_instances(
    credential_file: Path, profile: str, region: str
) -> set[tuple[str, str]]:
    """Return a set of instances and names that match the profile and region.

    Args:
        credential_file (Path): The path to the credential file.
        profile (str): The profile to use.
        region (str): The AWS region to use.

    Returns:
        set[tuple[str, str]]: A set of instances and names that match the profile and region.
    """
    # Create session
    # boto3 doesn't have a programatic way to set the credential file. yuck.
    os.environ["AWS_SHARED_CREDENTIALS_FILE"] = str(credential_file)
    session = boto3.session.Session(region_name=region, profile_name=profile)
    ec2 = session.resource("ec2")
    instances = {}
    # Loop through instances that are running
    for i in ec2.instances.filter(
        Filters=[{"Name": "instance-state-name", "Values": ["running"]}]
    ):
        # convert tags into a proper dictionary
        if i.tags is None:
            # if an instance has no tags use the id as the Name
            log(f"warning: instance does not have tags: {i}")
            i.tag_dict = {"Name": i.id}
        else:
            i.tag_dict = {tag["Key"]: tag["Value"] for tag in i.tags}
        instances[i.tag_dict["Name"]] = i

    result: set[tuple[str, str]] = set()
    for name, instance in instances.items():
        result.add((instance.id, name))
    return result


def build_option_candidates(word_set: set[str]) -> set[str]:
    """Return a set of command line option candidates for the given word set.

    Args:
        word_set (set[str]): The set of words to build option candidates for.

    Returns:
        set[str]: A set of command line option candidates for the given word set.
    """
    candidates: set[str] = set()
    if HELP_OPTIONS & word_set:
        return candidates
    if len(word_set) <= 1:
        candidates |= HELP_OPTIONS
    if not CREDENTIALS_OPTIONS & word_set:
        candidates |= CREDENTIALS_OPTIONS
    if not LOG_LEVEL_OPTIONS & word_set:
        candidates |= LOG_LEVEL_OPTIONS
    if not NO_SSH_OPTIONS & word_set:
        candidates |= NO_SSH_OPTIONS
    if not REGION_OPTIONS & word_set:
        candidates |= REGION_OPTIONS
    if not SSH_ARGS_OPTIONS & word_set:
        candidates |= SSH_ARGS_OPTIONS
    return candidates


@dataclass
class ParsedState:
    """A class to hold the state of the command line parser."""

    aws_region: Optional[str] = os.environ.get("AWS_REGION")
    cred_file: Path = Path(
        os.environ.get("AWS_SHARED_CREDENTIALS_FILE", DEFAULT_CREDENTIAL_FILE)
    )
    instance: Optional[str] = None
    profile: Optional[str] = None
    ssh_args: Optional[str] = None
    ssh_command: Optional[list[str]] = None


def parse_command_line(words: list[str]) -> ParsedState:
    """Parse the command line and return the parsed state.

    Args:
        words (list[str]): The command line words to parse.

    Returns:
        ParsedState: The parsed state.
    """
    state: ParsedState = ParsedState()
    pos_args: list[str] = []
    i = iter(words[:-1])
    try:
        while True:
            word = next(i)
            if word in CREDENTIALS_OPTIONS:
                state.cred_file = Path(CREDENTIAL_DIR) / Path(next(i))
            elif word in REGION_OPTIONS:
                state.aws_region = next(i)
            elif word in LOG_LEVEL_OPTIONS:
                next(i)  # don't care
            elif word in SSH_ARGS_OPTIONS:
                state.ssh_args = next(i)
            elif not word.startswith("-"):
                pos_args.append(word)
    except StopIteration:
        pass
    if pos_args:
        state.profile = pos_args.pop(0)
    if pos_args:
        state.instance = pos_args.pop(0)
    if pos_args:
        state.ssh_command = pos_args
    return state


def process_command_line(
    command_line: str, command_index: int
) -> tuple[list[str], str, str]:
    """Process the command line and return the command line words, the command, and the command index.

    Args:
        command_line (str): The command line to process.
        command_index (int): The index of the current command in the command line.

    Returns:
        tuple[list[str], str, str]: The command line words, the command, and the command index.
    """
    # Chop the command line at the current cursor location
    command_line = command_line[:command_index]
    log(f"chopped command line is: {command_line}")
    words = shlex.split(command_line)
    del words[0]  # delete the command itself
    if command_line[-1].isspace():
        # add a new empty word since we have a trailing space
        words.append("")
    cur_word = words[-1] if len(words) > 0 else ""
    prev_word = words[-2] if len(words) > 1 else ""
    log(f"words is {words}")
    log(f"cur_word is {cur_word}, prev_word is {prev_word}")
    return words, cur_word, prev_word


def autocomplete(command_line: str, command_index: int) -> tuple[set[str], str]:
    """Autocomplete the command line and return the autocomplete set and the current word.

    Args:
        command_line (str): The command line to autocomplete.
        command_index (int): The index of the current command in the command line.

    Returns:
        tuple(set[str], str): The autocomplete set and the current word.
    """
    log("-" * 40)
    log(f"command_line is {command_line}, command_index is {command_index}")
    words: list[str]
    cur_word: str
    prev_word: str
    words, cur_word, prev_word = process_command_line(command_line, command_index)
    word_set: set[str] = set(words)

    # Calculate the state from the current commandline
    state = parse_command_line(words)
    log(f"state is {state.__dict__}")

    # Build a list of candidate completions
    candidates: set[str] = set()

    # If we are working on an option, then suggest parameters for that option.
    if prev_word in CREDENTIALS_OPTIONS:
        candidates |= get_cred_files()
    elif prev_word in LOG_LEVEL_OPTIONS:
        candidates |= LOG_LEVELS
    elif prev_word in REGION_OPTIONS:
        candidates |= get_regions()
    else:
        # Not working on an option parameter
        if not state.profile:
            # If we don't have the positional profile argument, suggest options
            candidates |= build_option_candidates(word_set)

        # If we have enough optional information start suggesting positional parameters
        if state.cred_file.is_file() and state.aws_region:
            profile_filter = os.environ.get("AWSSH_PROFILE_FILTER")
            profiles = get_profiles(state.cred_file, profile_filter)
            if state.profile not in profiles:
                candidates |= profiles

            # If we have enough information suggest instance ids and names
            if not state.instance and state.profile in profiles:
                instances: set[tuple[str, str]] = get_instances(
                    state.cred_file, state.profile, state.aws_region
                )
                # Build sets of id-name pairs, and names alone
                instance_id_and_name: set[str] = {f"{i[0]} {i[1]}" for i in instances}
                instance_names: set[str] = {i[1] for i in instances}

                # Include the names alone.  They will be substituted with an
                # instance id when only one candidate is left.
                candidates |= instance_names

                # Filter instances now so we can strip off the name if there is only one
                filtered_id_and_name = {
                    i for i in instance_id_and_name if cur_word in i
                }
                if len(filtered_id_and_name) == 1:
                    # If there is only one matching instance, remove the Name suffix
                    candidates = {filtered_id_and_name.pop().split()[0]}
                else:
                    candidates |= instance_id_and_name

    return candidates, cur_word


def print_completions(comps: set[str], cur: str) -> None:
    """Output the completions to stdout.

    Args:
        comps (set[str]): The completions to output.
        cur (str): The current word.
    """
    log(f"completions: {sorted(comps)}")
    contains: list[str] = []
    starts: list[str] = []
    for i in sorted(comps):
        if i.startswith(cur):
            starts.append(i)
        if cur in i or cur == "":
            contains.append(i)
    log(f"starts with: {starts}")
    log(f"contains: {contains}")
    # Prefer completions in this order:
    # 1. completions that start with the current word
    # 2. completions that contain the current word
    # 3. other candidates that matched some other way (e.g., by instance name)
    for i in starts or contains or comps:
        print(i)


def main() -> None:
    """Execute main entry point for the awssh autocomplete script.

    Returns:
        None
    """
    # bash exports COMP_LINE and COMP_POINT, tcsh COMMAND_LINE only
    command_line: str = (
        os.environ.get("COMP_LINE") or os.environ.get("COMMAND_LINE") or ""
    )
    command_index: int = int(os.environ.get("COMP_POINT") or len(command_line))

    try:
        candidates: set[str]
        cur_word: str
        candidates, cur_word = autocomplete(command_line, command_index)

        print_completions(candidates, cur_word)
    except KeyboardInterrupt:
        # If the user hits Ctrl+C, we don't want to print
        # a traceback to the user.
        pass

    # Close log file if it exists
    if LOG_FILE:
        LOG_FILE.close()

1	"""AWS SSH autocompleter script."""
2
3	# Standard Python Libraries
4	import configparser	×
5	from dataclasses import dataclass	×
6	import os	×
7	from pathlib import Path	×
8	import re	×
9	import shlex	×
10	from typing import Optional, TextIO	×
11
12	# Third-Party Libraries
13	import boto3	×
14
15	from . import CREDENTIAL_DIR, DEFAULT_CREDENTIAL_FILE	×
16
17	CREDENTIALS_OPTIONS = {"--credentials", "-c"}	×
18	HELP_OPTIONS = {"--help", "-h"}	×
19	LOG_LEVEL_OPTIONS = {"--log-level"}	×
20	LOG_LEVELS = {"debug", "info", "warning", "error", "critical"}	×
NEW 21	NO_SSH_OPTIONS = {"--no-ssh", "-n"}	×
22	REGION_OPTIONS = {"--region", "-r"}	×
23	SSH_ARGS_OPTIONS = {"--ssh-args", "-s"}	×
24
UNCOV 25	if os.environ.get("LC_CTYPE", "") == "UTF-8":	×
26	os.environ["LC_CTYPE"] = "en_US.UTF-8"	×
27
28	# Debugging the completer can be touchy since standard out goes to bash.
29	# Set the environment below to a filename to enable logging.
UNCOV 30	LOG_FILE: Optional[TextIO] = None	×
31	if filename := os.environ.get("BASH_COMP_DEBUG_FILE"):	×
32	LOG_FILE = open(filename, "a", encoding="utf-8")	×
33
34
UNCOV 35	def log(message: str) -> None:	×
36	"""Log a message to the log file if it is open.
37
38	Args:
39	message (str): The message to log.
40	"""
UNCOV 41	if LOG_FILE:	×
42	print(message, file=LOG_FILE)	×
43
44
UNCOV 45	def get_cred_files() -> set[str]:	×
46	"""Return a set of all credential files in the credential directory.
47
48	Returns:
49	set[str]: A set of all credential files in the credential directory.
50	"""
UNCOV 51	result: set[str] = set()	×
52	for i in CREDENTIAL_DIR.iterdir():	×
53	if i.is_file():	×
54	result.add(i.name)	×
55	return result	×
56
57
UNCOV 58	def get_regions() -> set[str]:	×
59	"""Return a set of all available AWS regions.
60
61	Returns:
62	set[str]: A set of all available AWS regions.
63	"""
UNCOV 64	session = boto3.session.Session(region_name="us-east-1")	×
65	return set(session.get_available_regions("ec2"))	×
66
67
UNCOV 68	def get_profiles(cred_filename: Path, profile_filter: Optional[str] = None) -> set[str]:	×
69	"""Return a set of profiles within a credential file that match the filter.
70
71	Args:
72	cred_filename (Path): The path to the credential file.
73	profile_filter (Optional[str], optional): Regular expression to match profile names. Defaults to None.
74
75	Returns:
76	set[str]: A set of profiles within a credential file that match the filter.
77	"""
UNCOV 78	if profile_filter:	×
79	profile_filter_re: re.Pattern[str] = re.compile(profile_filter)	×
80	config = configparser.ConfigParser()	×
81	config.read(cred_filename)	×
82	result: set[str] = set()	×
83	for section in config.sections():	×
84	if not profile_filter_re or profile_filter_re.search(section):	×
85	result.add(section)	×
86	return result	×
87
88
UNCOV 89	def get_instances(	×
90	credential_file: Path, profile: str, region: str
91	) -> set[tuple[str, str]]:
92	"""Return a set of instances and names that match the profile and region.
93
94	Args:
95	credential_file (Path): The path to the credential file.
96	profile (str): The profile to use.
97	region (str): The AWS region to use.
98
99	Returns:
100	set[tuple[str, str]]: A set of instances and names that match the profile and region.
101	"""
102	# Create session
103	# boto3 doesn't have a programatic way to set the credential file. yuck.
UNCOV 104	os.environ["AWS_SHARED_CREDENTIALS_FILE"] = str(credential_file)	×
105	session = boto3.session.Session(region_name=region, profile_name=profile)	×
106	ec2 = session.resource("ec2")	×
107	instances = {}	×
108	# Loop through instances that are running
UNCOV 109	for i in ec2.instances.filter(	×
110	Filters=[{"Name": "instance-state-name", "Values": ["running"]}]
111	):
112	# convert tags into a proper dictionary
UNCOV 113	if i.tags is None:	×
114	# if an instance has no tags use the id as the Name
UNCOV 115	log(f"warning: instance does not have tags: {i}")	×
116	i.tag_dict = {"Name": i.id}	×
117	else:
UNCOV 118	i.tag_dict = {tag["Key"]: tag["Value"] for tag in i.tags}	×
119	instances[i.tag_dict["Name"]] = i	×
120
UNCOV 121	result: set[tuple[str, str]] = set()	×
122	for name, instance in instances.items():	×
123	result.add((instance.id, name))	×
124	return result	×
125
126
UNCOV 127	def build_option_candidates(word_set: set[str]) -> set[str]:	×
128	"""Return a set of command line option candidates for the given word set.
129
130	Args:
131	word_set (set[str]): The set of words to build option candidates for.
132
133	Returns:
134	set[str]: A set of command line option candidates for the given word set.
135	"""
UNCOV 136	candidates: set[str] = set()	×
137	if HELP_OPTIONS & word_set:	×
138	return candidates	×
139	if len(word_set) <= 1:	×
140	candidates \|= HELP_OPTIONS	×
141	if not CREDENTIALS_OPTIONS & word_set:	×
142	candidates \|= CREDENTIALS_OPTIONS	×
143	if not LOG_LEVEL_OPTIONS & word_set:	×
144	candidates \|= LOG_LEVEL_OPTIONS	×
NEW 145	if not NO_SSH_OPTIONS & word_set:	×
NEW 146	candidates \|= NO_SSH_OPTIONS	×
147	if not REGION_OPTIONS & word_set:	×
148	candidates \|= REGION_OPTIONS	×
149	if not SSH_ARGS_OPTIONS & word_set:	×
150	candidates \|= SSH_ARGS_OPTIONS	×
151	return candidates	×
152
153
154	@dataclass	×
UNCOV 155	class ParsedState:	×
156	"""A class to hold the state of the command line parser."""
157
158	aws_region: Optional[str] = os.environ.get("AWS_REGION")	×
UNCOV 159	cred_file: Path = Path(	×
160	os.environ.get("AWS_SHARED_CREDENTIALS_FILE", DEFAULT_CREDENTIAL_FILE)
161	)
162	instance: Optional[str] = None	×
UNCOV 163	profile: Optional[str] = None	×
UNCOV 164	ssh_args: Optional[str] = None	×
165	ssh_command: Optional[list[str]] = None	×
166
167
168	def parse_command_line(words: list[str]) -> ParsedState:	×
169	"""Parse the command line and return the parsed state.
170
171	Args:
172	words (list[str]): The command line words to parse.
173
174	Returns:
175	ParsedState: The parsed state.
176	"""
UNCOV 177	state: ParsedState = ParsedState()	×
UNCOV 178	pos_args: list[str] = []	×
UNCOV 179	i = iter(words[:-1])	×
180	try:	×
181	while True:
182	word = next(i)	×
183	if word in CREDENTIALS_OPTIONS:	×
UNCOV 184	state.cred_file = Path(CREDENTIAL_DIR) / Path(next(i))	×
185	elif word in REGION_OPTIONS:	×
186	state.aws_region = next(i)	×
187	elif word in LOG_LEVEL_OPTIONS:	×
188	next(i) # don't care	×
189	elif word in SSH_ARGS_OPTIONS:	×
190	state.ssh_args = next(i)	×
191	elif not word.startswith("-"):	×
192	pos_args.append(word)	×
193	except StopIteration:	×
194	pass	×
195	if pos_args:	×
196	state.profile = pos_args.pop(0)	×
197	if pos_args:	×
198	state.instance = pos_args.pop(0)	×
199	if pos_args:	×
200	state.ssh_command = pos_args	×
201	return state	×
202
203
204	def process_command_line(	×
205	command_line: str, command_index: int
206	) -> tuple[list[str], str, str]:
207	"""Process the command line and return the command line words, the command, and the command index.
208
209	Args:
210	command_line (str): The command line to process.
211	command_index (int): The index of the current command in the command line.
212
213	Returns:
214	tuple[list[str], str, str]: The command line words, the command, and the command index.
215	"""
216	# Chop the command line at the current cursor location
UNCOV 217	command_line = command_line[:command_index]	×
UNCOV 218	log(f"chopped command line is: {command_line}")	×
UNCOV 219	words = shlex.split(command_line)	×
220	del words[0] # delete the command itself	×
221	if command_line[-1].isspace():	×
222	# add a new empty word since we have a trailing space
223	words.append("")	×
224	cur_word = words[-1] if len(words) > 0 else ""	×
UNCOV 225	prev_word = words[-2] if len(words) > 1 else ""	×
226	log(f"words is {words}")	×
227	log(f"cur_word is {cur_word}, prev_word is {prev_word}")	×
228	return words, cur_word, prev_word	×
229
230
231	def autocomplete(command_line: str, command_index: int) -> tuple[set[str], str]:	×
232	"""Autocomplete the command line and return the autocomplete set and the current word.
233
234	Args:
235	command_line (str): The command line to autocomplete.
236	command_index (int): The index of the current command in the command line.
237
238	Returns:
239	tuple(set[str], str): The autocomplete set and the current word.
240	"""
UNCOV 241	log("-" * 40)	×
UNCOV 242	log(f"command_line is {command_line}, command_index is {command_index}")	×
243	words: list[str]
244	cur_word: str
245	prev_word: str
UNCOV 246	words, cur_word, prev_word = process_command_line(command_line, command_index)	×
UNCOV 247	word_set: set[str] = set(words)	×
248
249	# Calculate the state from the current commandline
250	state = parse_command_line(words)	×
UNCOV 251	log(f"state is {state.__dict__}")	×
252
253	# Build a list of candidate completions
254	candidates: set[str] = set()	×
255
256	# If we are working on an option, then suggest parameters for that option.
257	if prev_word in CREDENTIALS_OPTIONS:	×
UNCOV 258	candidates \|= get_cred_files()	×
UNCOV 259	elif prev_word in LOG_LEVEL_OPTIONS:	×
260	candidates \|= LOG_LEVELS	×
261	elif prev_word in REGION_OPTIONS:	×
262	candidates \|= get_regions()	×
263	else:
264	# Not working on an option parameter
265	if not state.profile:	×
266	# If we don't have the positional profile argument, suggest options
UNCOV 267	candidates \|= build_option_candidates(word_set)	×
268
269	# If we have enough optional information start suggesting positional parameters
270	if state.cred_file.is_file() and state.aws_region:	×
UNCOV 271	profile_filter = os.environ.get("AWSSH_PROFILE_FILTER")	×
UNCOV 272	profiles = get_profiles(state.cred_file, profile_filter)	×
273	if state.profile not in profiles:	×
274	candidates \|= profiles	×
275
276	# If we have enough information suggest instance ids and names
277	if not state.instance and state.profile in profiles:	×
UNCOV 278	instances: set[tuple[str, str]] = get_instances(	×
279	state.cred_file, state.profile, state.aws_region
280	)
281	# Build sets of id-name pairs, and names alone
UNCOV 282	instance_id_and_name: set[str] = {f"{i[0]} {i[1]}" for i in instances}	×
UNCOV 283	instance_names: set[str] = {i[1] for i in instances}	×
284
285	# Include the names alone. They will be substituted with an
286	# instance id when only one candidate is left.
UNCOV 287	candidates \|= instance_names	×
288
289	# Filter instances now so we can strip off the name if there is only one
290	filtered_id_and_name = {	×
291	i for i in instance_id_and_name if cur_word in i
292	}
293	if len(filtered_id_and_name) == 1:	×
294	# If there is only one matching instance, remove the Name suffix
UNCOV 295	candidates = {filtered_id_and_name.pop().split()[0]}	×
296	else:
UNCOV 297	candidates \|= instance_id_and_name	×
298
UNCOV 299	return candidates, cur_word	×
300
301
302	def print_completions(comps: set[str], cur: str) -> None:	×
303	"""Output the completions to stdout.
304
305	Args:
306	comps (set[str]): The completions to output.
307	cur (str): The current word.
308	"""
UNCOV 309	log(f"completions: {sorted(comps)}")	×
UNCOV 310	contains: list[str] = []	×
UNCOV 311	starts: list[str] = []	×
312	for i in sorted(comps):	×
313	if i.startswith(cur):	×
314	starts.append(i)	×
315	if cur in i or cur == "":	×
316	contains.append(i)	×
317	log(f"starts with: {starts}")	×
318	log(f"contains: {contains}")	×
319	# Prefer completions in this order:
320	# 1. completions that start with the current word
321	# 2. completions that contain the current word
322	# 3. other candidates that matched some other way (e.g., by instance name)
UNCOV 323	for i in starts or contains or comps:	×
UNCOV 324	print(i)	×
325
326
327	def main() -> None:	×
328	"""Execute main entry point for the awssh autocomplete script.
329
330	Returns:
331	None
332	"""
333	# bash exports COMP_LINE and COMP_POINT, tcsh COMMAND_LINE only
UNCOV 334	command_line: str = (	×
335	os.environ.get("COMP_LINE") or os.environ.get("COMMAND_LINE") or ""
336	)
337	command_index: int = int(os.environ.get("COMP_POINT") or len(command_line))	×
338
UNCOV 339	try:	×
340	candidates: set[str]
341	cur_word: str
342	candidates, cur_word = autocomplete(command_line, command_index)	×
343
UNCOV 344	print_completions(candidates, cur_word)	×
345	except KeyboardInterrupt:	×
346	# If the user hits Ctrl+C, we don't want to print
347	# a traceback to the user.
348	pass	×
349
350	# Close log file if it exists
351	if LOG_FILE:	×
UNCOV 352	LOG_FILE.close()	×

cisagov / awssh / 3810345645

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous