# -*- coding: utf-8 -*- """Classes for handling input/output prompts. Authors: * Fernando Perez * Brian Granger """ #----------------------------------------------------------------------------- # Copyright (C) 2008-2011 The IPython Development Team # Copyright (C) 2001-2007 Fernando Perez # # Distributed under the terms of the BSD License. The full license is in # the file COPYING, distributed as part of this software. #----------------------------------------------------------------------------- #----------------------------------------------------------------------------- # Imports #----------------------------------------------------------------------------- import os import re import socket import sys from IPython.core import release from IPython.external.Itpl import ItplNS from IPython.utils import coloransi #----------------------------------------------------------------------------- # Color schemes for prompts #----------------------------------------------------------------------------- PromptColors = coloransi.ColorSchemeTable() InputColors = coloransi.InputTermColors # just a shorthand Colors = coloransi.TermColors # just a shorthand PromptColors.add_scheme(coloransi.ColorScheme( 'NoColor', in_prompt = InputColors.NoColor, # Input prompt in_number = InputColors.NoColor, # Input prompt number in_prompt2 = InputColors.NoColor, # Continuation prompt in_normal = InputColors.NoColor, # color off (usu. Colors.Normal) out_prompt = Colors.NoColor, # Output prompt out_number = Colors.NoColor, # Output prompt number normal = Colors.NoColor # color off (usu. Colors.Normal) )) # make some schemes as instances so we can copy them for modification easily: __PColLinux = coloransi.ColorScheme( 'Linux', in_prompt = InputColors.Green, in_number = InputColors.LightGreen, in_prompt2 = InputColors.Green, in_normal = InputColors.Normal, # color off (usu. Colors.Normal) out_prompt = Colors.Red, out_number = Colors.LightRed, normal = Colors.Normal ) # Don't forget to enter it into the table! PromptColors.add_scheme(__PColLinux) # Slightly modified Linux for light backgrounds __PColLightBG = __PColLinux.copy('LightBG') __PColLightBG.colors.update( in_prompt = InputColors.Blue, in_number = InputColors.LightBlue, in_prompt2 = InputColors.Blue ) PromptColors.add_scheme(__PColLightBG) del Colors,InputColors #----------------------------------------------------------------------------- # Utilities #----------------------------------------------------------------------------- def multiple_replace(dict, text): """ Replace in 'text' all occurences of any key in the given dictionary by its corresponding value. Returns the new string.""" # Function by Xavier Defrang, originally found at: # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81330 # Create a regular expression from the dictionary keys regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys()))) # For each match, look-up corresponding value in dictionary return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text) #----------------------------------------------------------------------------- # Special characters that can be used in prompt templates, mainly bash-like #----------------------------------------------------------------------------- # If $HOME isn't defined (Windows), make it an absurd string so that it can # never be expanded out into '~'. Basically anything which can never be a # reasonable directory name will do, we just want the $HOME -> '~' operation # to become a no-op. We pre-compute $HOME here so it's not done on every # prompt call. # FIXME: # - This should be turned into a class which does proper namespace management, # since the prompt specials need to be evaluated in a certain namespace. # Currently it's just globals, which need to be managed manually by code # below. # - I also need to split up the color schemes from the prompt specials # somehow. I don't have a clean design for that quite yet. HOME = os.environ.get("HOME","//////:::::ZZZZZ,,,~~~") # We precompute a few more strings here for the prompt_specials, which are # fixed once ipython starts. This reduces the runtime overhead of computing # prompt strings. USER = os.environ.get("USER") HOSTNAME = socket.gethostname() HOSTNAME_SHORT = HOSTNAME.split(".")[0] ROOT_SYMBOL = "$#"[os.name=='nt' or os.getuid()==0] prompt_specials_color = { # Prompt/history count '%n' : '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}', r'\#': '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}', # Just the prompt counter number, WITHOUT any coloring wrappers, so users # can get numbers displayed in whatever color they want. r'\N': '${self.cache.prompt_count}', # Prompt/history count, with the actual digits replaced by dots. Used # mainly in continuation prompts (prompt_in2) #r'\D': '${"."*len(str(self.cache.prompt_count))}', # More robust form of the above expression, that uses the __builtin__ # module. Note that we can NOT use __builtins__ (note the 's'), because # that can either be a dict or a module, and can even mutate at runtime, # depending on the context (Python makes no guarantees on it). In # contrast, __builtin__ is always a module object, though it must be # explicitly imported. r'\D': '${"."*__builtin__.len(__builtin__.str(self.cache.prompt_count))}', # Current working directory r'\w': '${os.getcwd()}', # Current time r'\t' : '${time.strftime("%H:%M:%S")}', # Basename of current working directory. # (use os.sep to make this portable across OSes) r'\W' : '${os.getcwd().split("%s")[-1]}' % os.sep, # These X are an extension to the normal bash prompts. They return # N terms of the path, after replacing $HOME with '~' r'\X0': '${os.getcwd().replace("%s","~")}' % HOME, r'\X1': '${self.cwd_filt(1)}', r'\X2': '${self.cwd_filt(2)}', r'\X3': '${self.cwd_filt(3)}', r'\X4': '${self.cwd_filt(4)}', r'\X5': '${self.cwd_filt(5)}', # Y are similar to X, but they show '~' if it's the directory # N+1 in the list. Somewhat like %cN in tcsh. r'\Y0': '${self.cwd_filt2(0)}', r'\Y1': '${self.cwd_filt2(1)}', r'\Y2': '${self.cwd_filt2(2)}', r'\Y3': '${self.cwd_filt2(3)}', r'\Y4': '${self.cwd_filt2(4)}', r'\Y5': '${self.cwd_filt2(5)}', # Hostname up to first . r'\h': HOSTNAME_SHORT, # Full hostname r'\H': HOSTNAME, # Username of current user r'\u': USER, # Escaped '\' '\\\\': '\\', # Newline r'\n': '\n', # Carriage return r'\r': '\r', # Release version r'\v': release.version, # Root symbol ($ or #) r'\$': ROOT_SYMBOL, } # A copy of the prompt_specials dictionary but with all color escapes removed, # so we can correctly compute the prompt length for the auto_rewrite method. prompt_specials_nocolor = prompt_specials_color.copy() prompt_specials_nocolor['%n'] = '${self.cache.prompt_count}' prompt_specials_nocolor[r'\#'] = '${self.cache.prompt_count}' # Add in all the InputTermColors color escapes as valid prompt characters. # They all get added as \\C_COLORNAME, so that we don't have any conflicts # with a color name which may begin with a letter used by any other of the # allowed specials. This of course means that \\C will never be allowed for # anything else. input_colors = coloransi.InputTermColors for _color in dir(input_colors): if _color[0] != '_': c_name = r'\C_'+_color prompt_specials_color[c_name] = getattr(input_colors,_color) prompt_specials_nocolor[c_name] = '' # we default to no color for safety. Note that prompt_specials is a global # variable used by all prompt objects. prompt_specials = prompt_specials_nocolor #----------------------------------------------------------------------------- # More utilities #----------------------------------------------------------------------------- def str_safe(arg): """Convert to a string, without ever raising an exception. If str(arg) fails, is returned, where ... is the exception error message.""" try: out = str(arg) except UnicodeError: try: out = arg.encode('utf_8','replace') except Exception,msg: # let's keep this little duplication here, so that the most common # case doesn't suffer from a double try wrapping. out = '' % msg except Exception,msg: out = '' % msg #raise # dbg return out #----------------------------------------------------------------------------- # Prompt classes #----------------------------------------------------------------------------- class BasePrompt(object): """Interactive prompt similar to Mathematica's.""" def _get_p_template(self): return self._p_template def _set_p_template(self,val): self._p_template = val self.set_p_str() p_template = property(_get_p_template,_set_p_template, doc='Template for prompt string creation') def __init__(self, cache, sep, prompt, pad_left=False): # Hack: we access information about the primary prompt through the # cache argument. We need this, because we want the secondary prompt # to be aligned with the primary one. Color table info is also shared # by all prompt classes through the cache. Nice OO spaghetti code! self.cache = cache self.sep = sep # regexp to count the number of spaces at the end of a prompt # expression, useful for prompt auto-rewriting self.rspace = re.compile(r'(\s*)$') # Flag to left-pad prompt strings to match the length of the primary # prompt self.pad_left = pad_left # Set template to create each actual prompt (where numbers change). # Use a property self.p_template = prompt self.set_p_str() def set_p_str(self): """ Set the interpolating prompt strings. This must be called every time the color settings change, because the prompt_specials global may have changed.""" import os,time # needed in locals for prompt string handling loc = locals() try: self.p_str = ItplNS('%s%s%s' % ('${self.sep}${self.col_p}', multiple_replace(prompt_specials, self.p_template), '${self.col_norm}'),self.cache.shell.user_ns,loc) self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor, self.p_template), self.cache.shell.user_ns,loc) except: print "Illegal prompt template (check $ usage!):",self.p_template self.p_str = self.p_template self.p_str_nocolor = self.p_template def write(self, msg): sys.stdout.write(msg) return '' def __str__(self): """Return a string form of the prompt. This for is useful for continuation and output prompts, since it is left-padded to match lengths with the primary one (if the self.pad_left attribute is set).""" out_str = str_safe(self.p_str) if self.pad_left: # We must find the amount of padding required to match lengths, # taking the color escapes (which are invisible on-screen) into # account. esc_pad = len(out_str) - len(str_safe(self.p_str_nocolor)) format = '%%%ss' % (len(str(self.cache.last_prompt))+esc_pad) return format % out_str else: return out_str # these path filters are put in as methods so that we can control the # namespace where the prompt strings get evaluated def cwd_filt(self, depth): """Return the last depth elements of the current working directory. $HOME is always replaced with '~'. If depth==0, the full path is returned.""" cwd = os.getcwd().replace(HOME,"~") out = os.sep.join(cwd.split(os.sep)[-depth:]) if out: return out else: return os.sep def cwd_filt2(self, depth): """Return the last depth elements of the current working directory. $HOME is always replaced with '~'. If depth==0, the full path is returned.""" full_cwd = os.getcwd() cwd = full_cwd.replace(HOME,"~").split(os.sep) if '~' in cwd and len(cwd) == depth+1: depth += 1 drivepart = '' if sys.platform == 'win32' and len(cwd) > depth: drivepart = os.path.splitdrive(full_cwd)[0] out = drivepart + '/'.join(cwd[-depth:]) if out: return out else: return os.sep def __nonzero__(self): """Implement boolean behavior. Checks whether the p_str attribute is non-empty""" return bool(self.p_template) class Prompt1(BasePrompt): """Input interactive prompt similar to Mathematica's.""" def __init__(self, cache, sep='\n', prompt='In [\\#]: ', pad_left=True): BasePrompt.__init__(self, cache, sep, prompt, pad_left) def set_colors(self): self.set_p_str() Colors = self.cache.color_table.active_colors # shorthand self.col_p = Colors.in_prompt self.col_num = Colors.in_number self.col_norm = Colors.in_normal # We need a non-input version of these escapes for the '--->' # auto-call prompts used in the auto_rewrite() method. self.col_p_ni = self.col_p.replace('\001','').replace('\002','') self.col_norm_ni = Colors.normal def __str__(self): self.cache.last_prompt = str_safe(self.p_str_nocolor).split('\n')[-1] return str_safe(self.p_str) def auto_rewrite(self): """Return a string of the form '--->' which lines up with the previous input string. Useful for systems which re-write the user input when handling automatically special syntaxes.""" curr = str(self.cache.last_prompt) nrspaces = len(self.rspace.search(curr).group()) return '%s%s>%s%s' % (self.col_p_ni,'-'*(len(curr)-nrspaces-1), ' '*nrspaces,self.col_norm_ni) class PromptOut(BasePrompt): """Output interactive prompt similar to Mathematica's.""" def __init__(self, cache, sep='', prompt='Out[\\#]: ', pad_left=True): BasePrompt.__init__(self, cache, sep, prompt, pad_left) if not self.p_template: self.__str__ = lambda: '' def set_colors(self): self.set_p_str() Colors = self.cache.color_table.active_colors # shorthand self.col_p = Colors.out_prompt self.col_num = Colors.out_number self.col_norm = Colors.normal class Prompt2(BasePrompt): """Interactive continuation prompt.""" def __init__(self, cache, prompt=' .\\D.: ', pad_left=True): self.cache = cache self.p_template = prompt self.pad_left = pad_left self.set_p_str() def set_p_str(self): import os,time # needed in locals for prompt string handling loc = locals() self.p_str = ItplNS('%s%s%s' % ('${self.col_p2}', multiple_replace(prompt_specials, self.p_template), '$self.col_norm'), self.cache.shell.user_ns,loc) self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor, self.p_template), self.cache.shell.user_ns,loc) def set_colors(self): self.set_p_str() Colors = self.cache.color_table.active_colors self.col_p2 = Colors.in_prompt2 self.col_norm = Colors.in_normal # FIXME (2004-06-16) HACK: prevent crashes for users who haven't # updated their prompt_in2 definitions. Remove eventually. self.col_p = Colors.out_prompt self.col_num = Colors.out_number