"""

if platform.system() == 'Windows':

return WindowsHelpRenderer()

else:

"""

def __init__(self, output_stream=sys.stdout):

self.output_stream = output_stream

PAGER = None

def get_pager_cmdline(self):

pager = self.PAGER

if 'MANPAGER' in os.environ:

pager = os.environ['MANPAGER']

elif 'PAGER' in os.environ:

pager = os.environ['PAGER']

return shlex.split(pager)

def render(self, contents):

"""

converted_content = self._convert_doc_content(contents)

self._send_output_to_pager(converted_content)

def _send_output_to_pager(self, output):

cmdline = self.get_pager_cmdline()

LOG.debug("Running command: %s", cmdline)

p = self._popen(cmdline, stdin=PIPE)

p.communicate(input=output)

def _popen(self, *args, **kwargs):

return Popen(*args, **kwargs)

def _convert_doc_content(self, contents):

"""

PAGER = 'less -R'

def _convert_doc_content(self, contents):

man_contents = publish_string(contents, writer=manpage.Writer())

if not self._exists_on_path('groff'):

raise ExecutableNotFoundError('groff')

cmdline = ['groff', '-m', 'man', '-T', 'ascii']

LOG.debug("Running command: %s", cmdline)

p3 = self._popen(cmdline, stdin=PIPE, stdout=PIPE, stderr=PIPE)

groff_output = p3.communicate(input=man_contents)[0]

return groff_output

def _send_output_to_pager(self, output):

cmdline = self.get_pager_cmdline()

if not self._exists_on_path(cmdline[0]):

LOG.debug("Pager '%s' not found in PATH, printing raw help." %

cmdline[0])

self.output_stream.write(output.decode('utf-8') + "\n")

self.output_stream.flush()

return

LOG.debug("Running command: %s", cmdline)

with ignore_ctrl_c():

# We can't rely on the KeyboardInterrupt from

# the CLIDriver being caught because when we

# send the output to a pager it will use various

# control characters that need to be cleaned

# up gracefully. Otherwise if we simply catch

# the Ctrl-C and exit, it will likely leave the

# users terminals in a bad state and they'll need

# to manually run ``reset`` to fix this issue.

# Ignoring Ctrl-C solves this issue. It's also

# the default behavior of less (you can't ctrl-c

# out of a manpage).

p = self._popen(cmdline, stdin=PIPE)

p.communicate(input=output)

def _exists_on_path(self, name):

# Since we're only dealing with POSIX systems, we can

# ignore things like PATHEXT.

return any([os.path.exists(os.path.join(p, name))

"""Render help content on a Windows platform."""

PAGER = 'more'

def _convert_doc_content(self, contents):

text_output = publish_string(contents,

writer=TextWriter())

return text_output

def _popen(self, *args, **kwargs):

# Also set the shell value to True. To get any of the

# piping to a pager to work, we need to use shell=True.

kwargs['shell'] = True

"""

EventHandlerClass = None

"""

def __init__(self, session, obj, command_table, arg_table):

self.session = session

self.obj = obj

if command_table is None:

command_table = {}

self.command_table = command_table

if arg_table is None:

arg_table = {}

self.arg_table = arg_table

self._subcommand_table = {}

self._related_items = []

self.renderer = get_renderer()

self.doc = ReSTDocument(target='man')

@property

def event_class(self):

"""

pass

@property

def name(self):

"""

pass

@property

def subcommand_table(self):

"""These are the commands that may follow after the help command"""

return self._subcommand_table

@property

def related_items(self):

"""This is list of items that are related to the help command"""

return self._related_items

def __call__(self, args, parsed_globals):

if args:

subcommand_parser = ArgTableArgParser({}, self.subcommand_table)

parsed, remaining = subcommand_parser.parse_known_args(args)

if getattr(parsed, 'subcommand', None) is not None:

return self.subcommand_table[parsed.subcommand](remaining,

parsed_globals)

# Create an event handler for a Provider Document

instance = self.EventHandlerClass(self)

# Now generate all of the events for a Provider document.

# We pass ourselves along so that we can, in turn, get passed

# to all event handlers.

docevents.generate_events(self.session, self)

self.renderer.render(self.doc.getvalue())

"""Implements top level help command.

EventHandlerClass = ProviderDocumentEventHandler

def __init__(self, session, command_table, arg_table,

description, synopsis, usage):

HelpCommand.__init__(self, session, None,

command_table, arg_table)

self.description = description

self.synopsis = synopsis

self.help_usage = usage

self._subcommand_table = None

self._topic_tag_db = None

self._related_items = ['aws help topics']

@property

def event_class(self):

return 'aws'

@property

def name(self):

return 'aws'

@property

def subcommand_table(self):

if self._subcommand_table is None:

if self._topic_tag_db is None:

self._topic_tag_db = TopicTagDB()

self._topic_tag_db.load_json_index()

self._subcommand_table = self._create_subcommand_table()

return self._subcommand_table

def _create_subcommand_table(self):

subcommand_table = {}

# Add the ``aws help topics`` command to the ``topic_table``

topic_lister_command = TopicListerCommand(self.session)

subcommand_table['topics'] = topic_lister_command

topic_names = self._topic_tag_db.get_all_topic_names()

# Add all of the possible topics to the ``topic_table``

for topic_name in topic_names:

topic_help_command = TopicHelpCommand(self.session, topic_name)

subcommand_table[topic_name] = topic_help_command

"""Implements service level help.

EventHandlerClass = ServiceDocumentEventHandler

def __init__(self, session, obj, command_table, arg_table, name,

event_class):

super(ServiceHelpCommand, self).__init__(session, obj, command_table,

arg_table)

self._name = name

self._event_class = event_class

@property

def event_class(self):

return self._event_class

@property

def name(self):

"""Implements operation level help.

EventHandlerClass = OperationDocumentEventHandler

def __init__(self, session, operation_model, arg_table, name,

event_class):

HelpCommand.__init__(self, session, operation_model, None, arg_table)

self.param_shorthand = ParamShorthandParser()

self._name = name

self._event_class = event_class

@property

def event_class(self):

return self._event_class

@property

def name(self):

EventHandlerClass = TopicListerDocumentEventHandler

def __init__(self, session):

super(TopicListerCommand, self).__init__(session, None, {}, {})

@property

def event_class(self):

return 'topics'

@property

def name(self):

EventHandlerClass = TopicDocumentEventHandler

def __init__(self, session, topic_name):

super(TopicHelpCommand, self).__init__(session, None, {}, {})

self._topic_name = topic_name

@property

def event_class(self):

return 'topics.' + self.name

@property

def name(self):