Commits

Paul McLanahan  committed 8b87be2

Updated ipython config to new format
Added minor tweaks to merge/diff tools for hg.

  • Participants
  • Parent commits 49c787f

Comments (0)

Files changed (7)

File dotfiles/.bash_aliases

 alias rmpyc='find . -name "*.pyc" -delete'
 alias testsyncdb='python manage.py syncdb --settings=settings_local_test'
 alias testmigrate='python manage.py migrate --settings=settings_local_test'
-alias djsetuptest='django-test-setup.py -cm && testsyncdb && testmigrate'
+#alias djsetuptest='django-test-setup.py -cm && testsyncdb && testmigrate'
 alias djtest='python manage.py test --settings=settings_local_test'
 alias djrunserver='python manage.py runserver 0.0.0.0:8000'
 alias pysearch='find . -name "*.py" -o -name "*.html" -o -name "*.js" -o -name "*.css" | xargs grep -in'

File dotfiles/.hgignore

 *.un~
 *.kpf
 *.wpr
+*.egg-info
 .idea
 .vagrant
+.tox
 Vagrantfile

File dotfiles/.hgrc

 [extdiff]
 cmd.kdiff3 =
 cmd.meld =
-cmd.filemerge = opendiff-w
-cmd.opendiff = opendiff-w
+cmd.filemerge = /Users/pmclanahan/.local/bin/opendiff-w
+cmd.opendiff = /Users/pmclanahan/.local/bin/opendiff-w
 
 [merge-tools]
-filemerge.executable= opendiff-w
-filemerge.args=-left $other -right $local -ancestor $base -merge $output
-filemerge.gui=True
+filemerge.executable = /Users/pmclanahan/.local/bin/opendiff-w
+filemerge.args = $local $other -ancestor $base -merge $output
+filemerge.priority = 120
 
 kdiff3.args=--auto --L1 base --L2 local --L3 other $base $local $other -o $output
 kdiff3.regkey=Software\KDiff3
 gvimdiff.regname=path
 gvimdiff.priority=90
 
-vimdiff.args=$local $other $base
-vimdiff.priority=80
-
 meld.gui=True
 meld.args=--label='local' $local --label='base' $base --label='other' $other
 meld.diffargs=-a --label='$plabel1' $parent --label='$clabel' $child

File dotfiles/.ipython/ipy_user_conf.py

-""" User configuration file for IPython
-
-This is a more flexible and safe way to configure ipython than *rc files
-(ipythonrc, ipythonrc-pysh etc.)
-
-This file is always imported on ipython startup. You can import the
-ipython extensions you need here (see IPython/Extensions directory).
-
-Feel free to edit this file to customize your ipython experience.
-
-Note that as such this file does nothing, for backwards compatibility.
-Consult e.g. file 'ipy_profile_sh.py' for an example of the things 
-you can do here.
-
-See http://ipython.scipy.org/moin/IpythonExtensionApi for detailed
-description on what you could do here.
-"""
-
-# Most of your config files and extensions will probably start with this import
-
-import IPython.ipapi
-ip = IPython.ipapi.get()
-
-# You probably want to uncomment this if you did %upgrade -nolegacy
-# import ipy_defaults    
-
-import os   
-
-def main():   
-
-    # uncomment if you want to get ipython -p sh behaviour
-    # without having to use command line switches  
-    # import ipy_profile_sh
-
-    # Configure your favourite editor?
-    # Good idea e.g. for %edit os.path.isfile
-
-    #import ipy_editors
-    
-    # Choose one of these:
-    
-    #ipy_editors.scite()
-    #ipy_editors.scite('c:/opt/scite/scite.exe')
-    #ipy_editors.komodo()
-    #ipy_editors.idle()
-    # ... or many others, try 'ipy_editors??' after import to see them
-    
-    # Or roll your own:
-    #ipy_editors.install_editor("c:/opt/jed +$line $file")
-    
-    
-    o = ip.options
-    # An example on how to set options
-    #o.autocall = 1
-    o.system_verbose = 0
-    
-    #import_all("os sys")
-    #execf('~/_ipython/ns.py')
-
-
-    # -- prompt
-    # A different, more compact set of prompts from the default ones, that
-    # always show your current location in the filesystem:
-
-    #o.prompt_in1 = r'\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Normal\n\C_Green|\#>'
-    #o.prompt_in2 = r'.\D: '
-    #o.prompt_out = r'[\#] '
-    
-    # Try one of these color settings if you can't read the text easily
-    # autoexec is a list of IPython commands to execute on startup
-    #o.autoexec.append('%colors LightBG')
-    #o.autoexec.append('%colors NoColor')
-    #o.autoexec.append('%colors Linux')
-    
-    # for sane integer division that converts to float (1/2 == 0.5)
-    #o.autoexec.append('from __future__ import division')
-    
-    # For %tasks and %kill
-    #import jobctrl 
-    
-    # For autoreloading of modules (%autoreload, %aimport)    
-    #import ipy_autoreload
-    
-    # For winpdb support (%wdb)
-    #import ipy_winpdb
-    
-    # For bzr completer, requires bzrlib (the python installation of bzr)
-    #ip.load('ipy_bzr')
-    
-    # Tab completer that is not quite so picky (i.e. 
-    # "foo".<TAB> and str(2).<TAB> will work). Complete 
-    # at your own risk!
-    #import ipy_greedycompleter
-    
-    # If you are on Linux, you may be annoyed by
-    # "Display all N possibilities? (y or n)" on tab completion,
-    # as well as the paging through "more". Uncomment the following
-    # lines to disable that behaviour
-    #import readline
-    #readline.parse_and_bind('set completion-query-items 1000')
-    #readline.parse_and_bind('set page-completions no')
-
-
-# some config helper functions you can use 
-def import_all(modules):
-    """ Usage: import_all("os sys") """ 
-    for m in modules.split():
-        ip.ex("from %s import *" % m)
-
-def execf(fname):
-    """ Execute a file in user namespace """
-    ip.ex('execfile("%s")' % os.path.expanduser(fname))
-
-main()

File dotfiles/.ipython/ipythonrc

-# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
-
-#***************************************************************************
-#
-# Configuration file for IPython -- ipythonrc format
-#
-# ===========================================================
-# Deprecation note: you should look into modifying ipy_user_conf.py (located 
-# in ~/.ipython or ~/_ipython, depending on your platform) instead, it's a 
-# more flexible and robust (and better supported!) configuration
-# method.
-# ===========================================================
-#
-# The format of this file is simply one of 'key value' lines.
-# Lines containing only whitespace at the beginning and then a # are ignored
-# as comments. But comments can NOT be put on lines with data.
-
-# The meaning and use of each key are explained below.
-
-#---------------------------------------------------------------------------
-# Section: included files
-
-# Put one or more *config* files (with the syntax of this file) you want to
-# include. For keys with a unique value the outermost file has precedence. For
-# keys with multiple values, they all get assembled into a list which then
-# gets loaded by IPython.
-
-# In this file, all lists of things should simply be space-separated.
-
-# This allows you to build hierarchies of files which recursively load
-# lower-level services. If this is your main ~/.ipython/ipythonrc file, you
-# should only keep here basic things you always want available. Then you can
-# include it in every other special-purpose config file you create.
-include 
-
-#---------------------------------------------------------------------------
-# Section: startup setup
-
-# These are mostly things which parallel a command line option of the same
-# name.
-
-# Keys in this section should only appear once. If any key from this section
-# is encountered more than once, the last value remains, all earlier ones get
-# discarded.
-
-
-# Automatic calling of callable objects.  If set to 1 or 2, callable objects
-# are automatically called when invoked at the command line, even if you don't
-# type parentheses.  IPython adds the parentheses for you.  For example:
-
-#In [1]: str 45
-#------> str(45)
-#Out[1]: '45'
-
-# IPython reprints your line with '---->' indicating that it added
-# parentheses.  While this option is very convenient for interactive use, it
-# may occasionally cause problems with objects which have side-effects if
-# called unexpectedly.
-
-# The valid values for autocall are:
-
-# autocall 0 -> disabled (you can toggle it at runtime with the %autocall magic)
-
-# autocall 1 -> active, but do not apply if there are no arguments on the line.
-
-# In this mode, you get:
-
-#In [1]: callable
-#Out[1]: <built-in function callable>
-
-#In [2]: callable 'hello'
-#------> callable('hello')
-#Out[2]: False
-
-# 2 -> Active always.  Even if no arguments are present, the callable object
-# is called:
-
-#In [4]: callable
-#------> callable()
-
-# Note that even with autocall off, you can still use '/' at the start of a
-# line to treat the first argument on the command line as a function and add
-# parentheses to it:
-
-#In [8]: /str 43
-#------> str(43)
-#Out[8]: '43'
-
-autocall 1
-
-# Auto-edit syntax errors.  When you use the %edit magic in ipython to edit
-# source code (see the 'editor' variable below), it is possible that you save
-# a file with syntax errors in it.  If this variable is true, IPython will ask
-# you whether to re-open the editor immediately to correct such an error.
-
-autoedit_syntax 0
-
-# Auto-indent. IPython can recognize lines ending in ':' and indent the next
-# line, while also un-indenting automatically after 'raise' or 'return'.  
-
-# This feature uses the readline library, so it will honor your ~/.inputrc
-# configuration (or whatever file your INPUTRC variable points to).  Adding
-# the following lines to your .inputrc file can make indent/unindenting more
-# convenient (M-i indents, M-u unindents):
-
-#  $if Python
-#  "\M-i": "    "
-#  "\M-u": "\d\d\d\d"
-#  $endif
-
-# The feature is potentially a bit dangerous, because it can cause problems
-# with pasting of indented code (the pasted code gets re-indented on each
-# line).  But it's a huge time-saver when working interactively.  The magic
-# function %autoindent allows you to toggle it on/off at runtime.
-
-autoindent 1
-
-# Auto-magic. This gives you access to all the magic functions without having
-# to prepend them with an % sign. If you define a variable with the same name
-# as a magic function (say who=1), you will need to access the magic function
-# with % (%who in this example). However, if later you delete your variable
-# (del who), you'll recover the automagic calling form.
-
-# Considering that many magic functions provide a lot of shell-like
-# functionality, automagic gives you something close to a full Python+system
-# shell environment (and you can extend it further if you want).
-
-automagic 1
-
-# Size of the output cache. After this many entries are stored, the cache will
-# get flushed. Depending on the size of your intermediate calculations, you
-# may have memory problems if you make it too big, since keeping things in the
-# cache prevents Python from reclaiming the memory for old results. Experiment
-# with a value that works well for you.
-
-# If you choose cache_size 0 IPython will revert to python's regular >>>
-# unnumbered prompt. You will still have _, __ and ___ for your last three
-# results, but that will be it.  No dynamic _1, _2, etc. will be created. If
-# you are running on a slow machine or with very limited memory, this may
-# help.
-
-cache_size 1000
-
-# Classic mode: Setting 'classic 1' you lose many of IPython niceties,
-# but that's your choice! Classic 1 -> same as IPython -classic.
-# Note that this is _not_ the normal python interpreter, it's simply
-# IPython emulating most of the classic interpreter's behavior.
-classic 0
-
-# colors - Coloring option for prompts and traceback printouts.
-
-# Currently available schemes: NoColor, Linux, LightBG.
-
-# This option allows coloring the prompts and traceback printouts. This
-# requires a terminal which can properly handle color escape sequences. If you
-# are having problems with this, use the NoColor scheme (uses no color escapes
-# at all).
-
-# The Linux option works well in linux console type environments: dark
-# background with light fonts.
-
-# LightBG is similar to Linux but swaps dark/light colors to be more readable
-# in light background terminals.
-
-# keep uncommented only the one you want:
-colors Linux
-#colors LightBG
-#colors NoColor
-
-########################
-# Note to Windows users
-#
-# Color and readline support is avaialble to Windows users via Gary Bishop's
-# readline library.  You can find Gary's tools at
-# http://sourceforge.net/projects/uncpythontools.
-# Note that his readline module requires in turn the ctypes library, available
-# at http://starship.python.net/crew/theller/ctypes.
-########################
-
-# color_info: IPython can display information about objects via a set of
-# functions, and optionally can use colors for this, syntax highlighting
-# source code and various other elements. This information is passed through a
-# pager (it defaults to 'less' if $PAGER is not set). 
-
-# If your pager has problems, try to setting it to properly handle escapes
-# (see the less manpage for detail), or disable this option.  The magic
-# function %color_info allows you to toggle this interactively for testing.
-
-color_info 1
-
-# confirm_exit: set to 1 if you want IPython to confirm when you try to exit
-# with an EOF (Control-d in Unix, Control-Z/Enter in Windows). Note that using
-# the magic functions %Exit or %Quit you can force a direct exit, bypassing
-# any confirmation.
-
-confirm_exit 0
-
-# Use deep_reload() as a substitute for reload() by default. deep_reload() is
-# still available as dreload() and appears as a builtin.
-
-deep_reload 0
-
-# Which editor to use with the %edit command. If you leave this at 0, IPython
-# will honor your EDITOR environment variable. Since this editor is invoked on
-# the fly by ipython and is meant for editing small code snippets, you may
-# want to use a small, lightweight editor here.
-
-# For Emacs users, setting up your Emacs server properly as described in the
-# manual is a good idea. An alternative is to use jed, a very light editor
-# with much of the feel of Emacs (though not as powerful for heavy-duty work).
-
-editor 0
-
-# log 1 -> same as ipython -log. This automatically logs to ./ipython.log
-log 0
-
-# Same as ipython -Logfile YourLogfileName. 
-# Don't use with log 1 (use one or the other)
-logfile ''
-
-# banner 0 -> same as ipython -nobanner
-banner 1
-
-# messages 0 -> same as ipython -nomessages
-messages 1
-
-# Automatically call the pdb debugger after every uncaught exception. If you
-# are used to debugging using pdb, this puts you automatically inside of it
-# after any call (either in IPython or in code called by it) which triggers an
-# exception which goes uncaught.
-pdb 0
-
-# Enable the pprint module for printing. pprint tends to give a more readable
-# display (than print) for complex nested data structures.
-pprint 1
-
-# Prompt strings
-
-# Most bash-like escapes can be used to customize IPython's prompts, as well as
-# a few additional ones which are IPython-specific.  All valid prompt escapes
-# are described in detail in the Customization section of the IPython HTML/PDF
-# manual.
-
-# Use \# to represent the current prompt number, and quote them to protect
-# spaces.
-prompt_in1 'In [\#]: '
-
-# \D is replaced by as many dots as there are digits in the
-# current value of \#.
-prompt_in2 '   .\D.: '
-
-prompt_out 'Out[\#]: '
-
-# Select whether to left-pad the output prompts to match the length of the
-# input ones.  This allows you for example to use a simple '>' as an output
-# prompt, and yet have the output line up with the input.  If set to false,
-# the output prompts will be unpadded (flush left).
-prompts_pad_left 1
-
-# Pylab support: when ipython is started with the -pylab switch, by default it
-# executes 'from matplotlib.pylab import *'.  Set this variable to false if you
-# want to disable this behavior.
-
-# For details on pylab, see the matplotlib website:
-# http://matplotlib.sf.net
-pylab_import_all 1
-
-
-# quick 1 -> same as ipython -quick
-quick 0
-
-# Use the readline library (1) or not (0). Most users will want this on, but
-# if you experience strange problems with line management (mainly when using
-# IPython inside Emacs buffers) you may try disabling it. Not having it on
-# prevents you from getting command history with the arrow keys, searching and
-# name completion using TAB.
-
-readline 1
-
-# Screen Length: number of lines of your screen. This is used to control
-# printing of very long strings. Strings longer than this number of lines will
-# be paged with the less command instead of directly printed.
-
-# The default value for this is 0, which means IPython will auto-detect your
-# screen size every time it needs to print. If for some reason this isn't
-# working well (it needs curses support), specify it yourself. Otherwise don't
-# change the default.
-
-screen_length 0
-
-# Prompt separators for input and output.
-# Use \n for newline explicitly, without quotes.
-# Use 0 (like at the cmd line) to turn off a given separator.
-
-# The structure of prompt printing is:
-# (SeparateIn)Input....
-# (SeparateOut)Output...
-# (SeparateOut2),   # that is, no newline is printed after Out2
-# By choosing these you can organize your output any way you want.
-
-separate_in \n
-separate_out 0
-separate_out2 0
-
-# 'nosep 1' is a shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2 0'.
-# Simply removes all input/output separators, overriding the choices above.
-nosep 0
-
-# Wildcard searches - IPython has a system for searching names using
-# shell-like wildcards; type %psearch? for details.  This variables sets
-# whether by default such searches should be case sensitive or not.  You can
-# always override the default at the system command line or the IPython
-# prompt.
-
-wildcards_case_sensitive 1
-
-# Object information: at what level of detail to display the string form of an
-# object.  If set to 0, ipython will compute the string form of any object X,
-# by calling str(X), when X? is typed.  If set to 1, str(X) will only be
-# computed when X?? is given, and if set to 2 or higher, it will never be
-# computed (there is no X??? level of detail).  This is mostly of use to
-# people who frequently manipulate objects whose string representation is
-# extremely expensive to compute.
-
-object_info_string_level 0
-
-# xmode - Exception reporting mode. 
-
-# Valid modes: Plain, Context and Verbose.
-
-# Plain: similar to python's normal traceback printing.
-
-# Context: prints 5 lines of context source code around each line in the
-# traceback.
-
-# Verbose: similar to Context, but additionally prints the variables currently
-# visible where the exception happened (shortening their strings if too
-# long). This can potentially be very slow, if you happen to have a huge data
-# structure whose string representation is complex to compute. Your computer
-# may appear to freeze for a while with cpu usage at 100%. If this occurs, you
-# can cancel the traceback with Ctrl-C (maybe hitting it more than once).
-
-#xmode Plain
-xmode Context
-#xmode Verbose
-
-# multi_line_specials: if true, allow magics, aliases and shell escapes (via
-# !cmd) to be used in multi-line input (like for loops).  For example, if you
-# have this active, the following is valid in IPython:
-#
-#In [17]: for i in range(3):
-#   ....:     mkdir $i
-#   ....:     !touch $i/hello
-#   ....:     ls -l $i
-
-multi_line_specials 1
-
-
-# System calls: When IPython makes system calls (e.g. via special syntax like
-# !cmd or !!cmd, or magics like %sc or %sx), it can print the command it is
-# executing to standard output, prefixed by a header string.
-
-system_header "IPython system call: "
-
-system_verbose 1
-
-# wxversion: request a specific wxPython version (used for -wthread)
-
-# Set this to the value of wxPython you want to use, but note that this
-# feature requires you to have the wxversion Python module to work.  If you
-# don't have the wxversion module (try 'import wxversion' at the prompt to
-# check) or simply want to leave the system to pick up the default, leave this
-# variable at 0.
-
-wxversion 0
-
-#---------------------------------------------------------------------------
-# Section: Readline configuration (readline is not available for MS-Windows)
-
-# This is done via the following options:
-
-# (i) readline_parse_and_bind: this option can appear as many times as you
-# want, each time defining a string to be executed via a
-# readline.parse_and_bind() command. The syntax for valid commands of this
-# kind can be found by reading the documentation for the GNU readline library,
-# as these commands are of the kind which readline accepts in its
-# configuration file.
-
-# The TAB key can be used to complete names at the command line in one of two
-# ways: 'complete' and 'menu-complete'. The difference is that 'complete' only
-# completes as much as possible while 'menu-complete' cycles through all
-# possible completions. Leave the one you prefer uncommented.
-
-readline_parse_and_bind tab: complete
-#readline_parse_and_bind tab: menu-complete
-
-# This binds Control-l to printing the list of all possible completions when
-# there is more than one (what 'complete' does when hitting TAB twice, or at
-# the first TAB if show-all-if-ambiguous is on)
-readline_parse_and_bind "\C-l": possible-completions
-
-# This forces readline to automatically print the above list when tab
-# completion is set to 'complete'. You can still get this list manually by
-# using the key bound to 'possible-completions' (Control-l by default) or by
-# hitting TAB twice. Turning this on makes the printing happen at the first
-# TAB.
-readline_parse_and_bind set show-all-if-ambiguous on
-
-# If you have TAB set to complete names, you can rebind any key (Control-o by
-# default) to insert a true TAB character.
-readline_parse_and_bind "\C-o": tab-insert
-
-# These commands allow you to indent/unindent easily, with the 4-space
-# convention of the Python coding standards.  Since IPython's internal
-# auto-indent system also uses 4 spaces, you should not change the number of
-# spaces in the code below.
-readline_parse_and_bind "\M-i": "    "
-readline_parse_and_bind "\M-o": "\d\d\d\d"
-readline_parse_and_bind "\M-I": "\d\d\d\d"
-
-# Bindings for incremental searches in the history. These searches use the
-# string typed so far on the command line and search anything in the previous
-# input history containing them.
-readline_parse_and_bind "\C-r": reverse-search-history
-readline_parse_and_bind "\C-s": forward-search-history
-
-# Bindings for completing the current line in the history of previous
-# commands. This allows you to recall any previous command by typing its first
-# few letters and hitting Control-p, bypassing all intermediate commands which
-# may be in the history (much faster than hitting up-arrow 50 times!)
-readline_parse_and_bind "\C-p": history-search-backward
-readline_parse_and_bind "\C-n": history-search-forward
-
-# I also like to have the same functionality on the plain arrow keys. If you'd
-# rather have the arrows use all the history (and not just match what you've
-# typed so far), comment out or delete the next two lines.
-readline_parse_and_bind "\e[A": history-search-backward
-readline_parse_and_bind "\e[B": history-search-forward
-
-# These are typically on by default under *nix, but not win32.
-readline_parse_and_bind "\C-k": kill-line
-readline_parse_and_bind "\C-u": unix-line-discard
-
-# (ii) readline_remove_delims: a string of characters to be removed from the
-# default word-delimiters list used by readline, so that completions may be
-# performed on strings which contain them.
-
-readline_remove_delims -/~
-
-# (iii) readline_merge_completions: whether to merge the result of all
-# possible completions or not.  If true, IPython will complete filenames,
-# python names and aliases and return all possible completions.  If you set it
-# to false, each completer is used at a time, and only if it doesn't return
-# any completions is the next one used.
-
-# The default order is: [python_matches, file_matches, alias_matches]
-
-readline_merge_completions 1
-
-# (iv) readline_omit__names: normally hitting <tab> after a '.' in a name
-# will complete all attributes of an object, including all the special methods
-# whose names start with single or double underscores (like __getitem__ or
-# __class__).
-
-# This variable allows you to control this completion behavior:
-
-# readline_omit__names 1 -> completion will omit showing any names starting
-# with two __, but it will still show names starting with one _.
-
-# readline_omit__names 2 -> completion will omit all names beginning with one
-# _ (which obviously means filtering out the double __ ones).
-
-# Even when this option is set, you can still see those names by explicitly
-# typing a _ after the period and hitting <tab>: 'name._<tab>' will always
-# complete attribute names starting with '_'.
-
-# This option is off by default so that new users see all attributes of any
-# objects they are dealing with.
-
-readline_omit__names 0
-
-#---------------------------------------------------------------------------
-# Section: modules to be loaded with 'import ...'
-
-# List, separated by spaces, the names of the modules you want to import
-
-# Example:
-# import_mod sys os
-# will produce internally the statements
-# import sys
-# import os
-
-# Each import is executed in its own try/except block, so if one module
-# fails to load the others will still be ok.
-
-import_mod 
-
-#---------------------------------------------------------------------------
-# Section: modules to import some functions from: 'from ... import ...'
-
-# List, one per line, the modules for which you want only to import some
-# functions. Give the module name first and then the name of functions to be
-# imported from that module.
-
-# Example:
-
-# import_some IPython.genutils timing timings
-# will produce internally the statement
-# from IPython.genutils import timing, timings
-
-# timing() and timings() are two IPython utilities for timing the execution of
-# your own functions, which you may find useful.  Just commment out the above
-# line if you want to test them.
-
-# If you have more than one modules_some line, each gets its own try/except
-# block (like modules, see above).
-
-import_some 
-
-#---------------------------------------------------------------------------
-# Section: modules to import all from : 'from ... import *'
-
-# List (same syntax as import_mod above) those modules for which you want to
-# import all functions. Remember, this is a potentially dangerous thing to do,
-# since it is very easy to overwrite names of things you need. Use with
-# caution.
-
-# Example:
-# import_all sys os
-# will produce internally the statements
-# from sys import *
-# from os import *
-
-# As before, each will be called in a separate try/except block.
-
-import_all 
-
-#---------------------------------------------------------------------------
-# Section: Python code to execute.
-
-# Put here code to be explicitly executed (keep it simple!)
-# Put one line of python code per line. All whitespace is removed (this is a
-# feature, not a bug), so don't get fancy building loops here.
-# This is just for quick convenient creation of things you want available.
-
-# Example:
-# execute x = 1
-# execute print 'hello world'; y = z = 'a'
-# will produce internally
-# x = 1
-# print 'hello world'; y = z = 'a'
-# and each *line* (not each statement, we don't do python syntax parsing) is
-# executed in its own try/except block.
-
-execute 
-
-# Note for the adventurous: you can use this to define your own names for the
-# magic functions, by playing some namespace tricks:
-
-# execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
-
-# defines %pf as a new name for %profile.
-
-#---------------------------------------------------------------------------
-# Section: Pyhton files to load and execute.
-
-# Put here the full names of files you want executed with execfile(file).  If
-# you want complicated initialization, just write whatever you want in a
-# regular python file and load it from here.
-
-# Filenames defined here (which *must* include the extension) are searched for
-# through all of sys.path. Since IPython adds your .ipython directory to
-# sys.path, they can also be placed in your .ipython dir and will be
-# found. Otherwise (if you want to execute things not in .ipyton nor in
-# sys.path) give a full path (you can use ~, it gets expanded)
-
-# Example:
-# execfile file1.py ~/file2.py
-# will generate
-# execfile('file1.py')
-# execfile('_path_to_your_home/file2.py')
-
-# As before, each file gets its own try/except block.
-
-execfile
-
-# If you are feeling adventurous, you can even add functionality to IPython
-# through here. IPython works through a global variable called __ip which
-# exists at the time when these files are read. If you know what you are doing
-# (read the source) you can add functions to __ip in files loaded here. 
-
-# The file example-magic.py contains a simple but correct example. Try it:
-
-# execfile example-magic.py
-
-# Look at the examples in IPython/iplib.py for more details on how these magic
-# functions need to process their arguments.
-
-#---------------------------------------------------------------------------
-# Section: aliases for system shell commands
-
-# Here you can define your own names for system commands. The syntax is
-# similar to that of the builtin %alias function:
-
-# alias alias_name command_string
-
-# The resulting aliases are auto-generated magic functions (hence usable as
-# %alias_name)
-
-# For example:
-
-# alias myls ls -la
-
-# will define 'myls' as an alias for executing the system command 'ls -la'.
-# This allows you to customize IPython's environment to have the same aliases
-# you are accustomed to from your own shell.
-
-# You can also define aliases with parameters using %s specifiers (one per
-# parameter):
-
-# alias parts echo first %s second %s
-
-# will give you in IPython:
-# >>> %parts A B
-# first A second B
-
-# Use one 'alias' statement per alias you wish to define.
-
-# alias 
-
-#************************* end of file <ipythonrc> ************************

File dotfiles/.ipython/profile_default/ipython_config.py

+# Configuration file for ipython.
+
+c = get_config()
+
+#------------------------------------------------------------------------------
+# TerminalIPythonApp configuration
+#------------------------------------------------------------------------------
+
+# TerminalIPythonApp will inherit config from: BaseIPythonApplication,
+# Application, InteractiveShellApp
+
+# Execute the given command string.
+# c.TerminalIPythonApp.code_to_run = ''
+
+# The IPython profile to use.
+# c.TerminalIPythonApp.profile = u'default'
+
+# Set the log level by value or name.
+# c.TerminalIPythonApp.log_level = 30
+
+# lines of code to run at IPython startup.
+# c.TerminalIPythonApp.exec_lines = []
+
+# Enable GUI event loop integration ('qt', 'wx', 'gtk').
+# c.TerminalIPythonApp.gui = None
+
+# Pre-load matplotlib and numpy for interactive use, selecting a particular
+# matplotlib backend and loop integration.
+# c.TerminalIPythonApp.pylab = None
+
+# Suppress warning messages about legacy config files
+# c.TerminalIPythonApp.ignore_old_config = False
+
+# If a command or file is given via the command-line, e.g. 'ipython foo.py
+# c.TerminalIPythonApp.force_interact = False
+
+# The name of the IPython directory. This directory is used for logging
+# configuration (through profiles), history storage, etc. The default is usually
+# $HOME/.ipython. This options can also be specified through the environment
+# variable IPYTHON_DIR.
+# c.TerminalIPythonApp.ipython_dir = u'/Users/pmclanahan/.ipython'
+
+# Whether to display a banner upon starting IPython.
+# c.TerminalIPythonApp.display_banner = True
+
+# Start IPython quickly by skipping the loading of config files.
+# c.TerminalIPythonApp.quick = False
+
+# A list of dotted module names of IPython extensions to load.
+# c.TerminalIPythonApp.extensions = []
+
+# Whether to install the default config files into the profile dir. If a new
+# profile is being created, and IPython contains config files for that profile,
+# then they will be staged into the new directory.  Otherwise, default config
+# files will be automatically generated.
+# c.TerminalIPythonApp.copy_config_files = False
+
+# dotted module name of an IPython extension to load.
+# c.TerminalIPythonApp.extra_extension = ''
+
+# List of files to run at IPython startup.
+# c.TerminalIPythonApp.exec_files = []
+
+# Whether to overwrite existing config files when copying
+# c.TerminalIPythonApp.overwrite = False
+
+# A file to be run
+# c.TerminalIPythonApp.file_to_run = ''
+
+#------------------------------------------------------------------------------
+# TerminalIPythonApp configuration
+#------------------------------------------------------------------------------
+
+# TerminalIPythonApp will inherit config from: BaseIPythonApplication,
+# Application, InteractiveShellApp
+
+# Execute the given command string.
+# c.TerminalIPythonApp.code_to_run = ''
+
+# The IPython profile to use.
+# c.TerminalIPythonApp.profile = u'default'
+
+# Set the log level by value or name.
+# c.TerminalIPythonApp.log_level = 30
+
+# lines of code to run at IPython startup.
+# c.TerminalIPythonApp.exec_lines = []
+
+# Enable GUI event loop integration ('qt', 'wx', 'gtk').
+# c.TerminalIPythonApp.gui = None
+
+# Pre-load matplotlib and numpy for interactive use, selecting a particular
+# matplotlib backend and loop integration.
+# c.TerminalIPythonApp.pylab = None
+
+# Suppress warning messages about legacy config files
+# c.TerminalIPythonApp.ignore_old_config = False
+
+# If a command or file is given via the command-line, e.g. 'ipython foo.py
+# c.TerminalIPythonApp.force_interact = False
+
+# The name of the IPython directory. This directory is used for logging
+# configuration (through profiles), history storage, etc. The default is usually
+# $HOME/.ipython. This options can also be specified through the environment
+# variable IPYTHON_DIR.
+# c.TerminalIPythonApp.ipython_dir = u'/Users/pmclanahan/.ipython'
+
+# Whether to display a banner upon starting IPython.
+# c.TerminalIPythonApp.display_banner = True
+
+# Start IPython quickly by skipping the loading of config files.
+# c.TerminalIPythonApp.quick = False
+
+# A list of dotted module names of IPython extensions to load.
+# c.TerminalIPythonApp.extensions = []
+
+# Whether to install the default config files into the profile dir. If a new
+# profile is being created, and IPython contains config files for that profile,
+# then they will be staged into the new directory.  Otherwise, default config
+# files will be automatically generated.
+# c.TerminalIPythonApp.copy_config_files = False
+
+# dotted module name of an IPython extension to load.
+# c.TerminalIPythonApp.extra_extension = ''
+
+# List of files to run at IPython startup.
+# c.TerminalIPythonApp.exec_files = []
+
+# Whether to overwrite existing config files when copying
+# c.TerminalIPythonApp.overwrite = False
+
+# A file to be run
+# c.TerminalIPythonApp.file_to_run = ''
+
+#------------------------------------------------------------------------------
+# InteractiveShellApp configuration
+#------------------------------------------------------------------------------
+
+# A Mixin for applications that start InteractiveShell instances.
+# 
+# Provides configurables for loading extensions and executing files as part of
+# configuring a Shell environment.
+# 
+# Provides init_extensions() and init_code() methods, to be called after
+# init_shell(), which must be implemented by subclasses.
+
+# Execute the given command string.
+# c.InteractiveShellApp.code_to_run = ''
+
+# lines of code to run at IPython startup.
+# c.InteractiveShellApp.exec_lines = []
+
+# A list of dotted module names of IPython extensions to load.
+# c.InteractiveShellApp.extensions = []
+
+# dotted module name of an IPython extension to load.
+# c.InteractiveShellApp.extra_extension = ''
+
+# List of files to run at IPython startup.
+# c.InteractiveShellApp.exec_files = []
+
+# A file to be run
+# c.InteractiveShellApp.file_to_run = ''
+
+#------------------------------------------------------------------------------
+# TerminalInteractiveShell configuration
+#------------------------------------------------------------------------------
+
+# TerminalInteractiveShell will inherit config from: InteractiveShell
+
+# auto editing of files with syntax errors.
+# c.TerminalInteractiveShell.autoedit_syntax = False
+
+# Use colors for displaying information about objects. Because this information
+# is passed through a pager (like 'less'), and some pagers get confused with
+# color codes, this capability can be turned off.
+# c.TerminalInteractiveShell.color_info = True
+
+# 
+# c.TerminalInteractiveShell.history_length = 10000
+
+# 
+# c.TerminalInteractiveShell.separate_in = '\n'
+
+# Set the color scheme (NoColor, Linux, or LightBG).
+# c.TerminalInteractiveShell.colors = 'LightBG'
+
+# Autoindent IPython code entered interactively.
+# c.TerminalInteractiveShell.autoindent = True
+
+# 
+# c.TerminalInteractiveShell.readline_omit__names = 2
+
+# 
+# c.TerminalInteractiveShell.prompt_in2 = '   .\\D.: '
+
+# 
+# c.TerminalInteractiveShell.separate_out = ''
+
+# 
+# c.TerminalInteractiveShell.prompt_in1 = 'In [\\#]: '
+
+# Enable deep (recursive) reloading by default. IPython can use the deep_reload
+# module which reloads changes in modules recursively (it replaces the reload()
+# function, so you don't need to change anything to use it). deep_reload()
+# forces a full reload of modules whose code may have changed, which the default
+# reload() function does not.  When deep_reload is off, IPython will use the
+# normal reload(), but deep_reload will still be available as dreload().
+# c.TerminalInteractiveShell.deep_reload = False
+
+# 
+# c.TerminalInteractiveShell.debug = False
+
+# Make IPython automatically call any callable object even if you didn't type
+# explicit parentheses. For example, 'str 43' becomes 'str(43)' automatically.
+# The value can be '0' to disable the feature, '1' for 'smart' autocall, where
+# it is not applied if there are no more arguments on the line, and '2' for
+# 'full' autocall, where all callable objects are automatically called (even if
+# no arguments are present). The default is '1'.
+# c.TerminalInteractiveShell.autocall = 1
+
+# Number of lines of your screen, used to control printing of very long strings.
+# Strings longer than this number of lines will be sent through a pager instead
+# of directly printed.  The default value for this is 0, which means IPython
+# will auto-detect your screen size every time it needs to print certain
+# potentially long strings (this doesn't change the behavior of the 'print'
+# keyword, it's only triggered internally). If for some reason this isn't
+# working well (it needs curses support), specify it yourself. Otherwise don't
+# change the default.
+# c.TerminalInteractiveShell.screen_length = 0
+
+# Set the editor used by IPython (default to $EDITOR/vi/notepad).
+# c.TerminalInteractiveShell.editor = 'subl -w'
+
+# 
+# c.TerminalInteractiveShell.prompts_pad_left = True
+
+# The part of the banner to be printed before the profile
+# c.TerminalInteractiveShell.banner1 = 'Python 2.7.2 (default, Aug  1 2011, 12:16:54) \nType "copyright", "credits" or "license" for more information.\n\nIPython 0.11 -- An enhanced Interactive Python.\n?         -> Introduction and overview of IPython\'s features.\n%quickref -> Quick reference.\nhelp      -> Python\'s own help system.\nobject?   -> Details about \'object\', use \'object??\' for extra details.\n'
+
+# 
+# c.TerminalInteractiveShell.readline_parse_and_bind = ['tab: complete', '"\\C-l": clear-screen', 'set show-all-if-ambiguous on', '"\\C-o": tab-insert', '"\\C-r": reverse-search-history', '"\\C-s": forward-search-history', '"\\C-p": history-search-backward', '"\\C-n": history-search-forward', '"\\e[A": history-search-backward', '"\\e[B": history-search-forward', '"\\C-k": kill-line', '"\\C-u": unix-line-discard']
+
+# The part of the banner to be printed after the profile
+# c.TerminalInteractiveShell.banner2 = ''
+
+# 
+# c.TerminalInteractiveShell.separate_out2 = ''
+
+# 
+# c.TerminalInteractiveShell.wildcards_case_sensitive = True
+
+# 
+# c.TerminalInteractiveShell.readline_merge_completions = True
+
+# Set to confirm when you try to exit IPython with an EOF (Control-D in Unix,
+# Control-Z/Enter in Windows). By typing 'exit' or 'quit', you can force a
+# direct exit without any confirmation.
+c.TerminalInteractiveShell.confirm_exit = False
+
+# 
+# c.TerminalInteractiveShell.ipython_dir = ''
+
+# 
+# c.TerminalInteractiveShell.readline_remove_delims = '-/~'
+
+# Start logging to the default log file.
+# c.TerminalInteractiveShell.logstart = False
+
+# The name of the logfile to use.
+# c.TerminalInteractiveShell.logfile = ''
+
+# The shell program to be used for paging.
+# c.TerminalInteractiveShell.pager = 'less'
+
+# Enable magic commands to be called without the leading %.
+# c.TerminalInteractiveShell.automagic = True
+
+# 
+# c.TerminalInteractiveShell.readline_use = True
+
+# Start logging to the given file in append mode.
+# c.TerminalInteractiveShell.logappend = ''
+
+# 
+# c.TerminalInteractiveShell.xmode = 'Context'
+
+# 
+# c.TerminalInteractiveShell.quiet = False
+
+# Enable auto setting the terminal title.
+# c.TerminalInteractiveShell.term_title = False
+
+# 
+# c.TerminalInteractiveShell.object_info_string_level = 0
+
+# 
+# c.TerminalInteractiveShell.prompt_out = 'Out[\\#]: '
+
+# Set the size of the output cache.  The default is 1000, you can change it
+# permanently in your config file.  Setting it to 0 completely disables the
+# caching system, and the minimum value accepted is 20 (if you provide a value
+# less than 20, it is reset to 0 and a warning is issued).  This limit is
+# defined because otherwise you'll spend more time re-flushing a too small cache
+# than working
+# c.TerminalInteractiveShell.cache_size = 1000
+
+# Automatically call the pdb debugger after every exception.
+# c.TerminalInteractiveShell.pdb = False
+
+#------------------------------------------------------------------------------
+# ProfileDir configuration
+#------------------------------------------------------------------------------
+
+# An object to manage the profile directory and its resources.
+# 
+# The profile directory is used by all IPython applications, to manage
+# configuration, logging and security.
+# 
+# This object knows how to find, create and manage these directories. This
+# should be used by any code that wants to handle profiles.
+
+# Set the profile location directly. This overrides the logic used by the
+# `profile` option.
+# c.ProfileDir.location = u''
+
+#------------------------------------------------------------------------------
+# PlainTextFormatter configuration
+#------------------------------------------------------------------------------
+
+# The default pretty-printer.
+# 
+# This uses :mod:`IPython.external.pretty` to compute the format data of the
+# object. If the object cannot be pretty printed, :func:`repr` is used. See the
+# documentation of :mod:`IPython.external.pretty` for details on how to write
+# pretty printers.  Here is a simple example::
+# 
+#     def dtype_pprinter(obj, p, cycle):
+#         if cycle:
+#             return p.text('dtype(...)')
+#         if hasattr(obj, 'fields'):
+#             if obj.fields is None:
+#                 p.text(repr(obj))
+#             else:
+#                 p.begin_group(7, 'dtype([')
+#                 for i, field in enumerate(obj.descr):
+#                     if i > 0:
+#                         p.text(',')
+#                         p.breakable()
+#                     p.pretty(field)
+#                 p.end_group(7, '])')
+
+# PlainTextFormatter will inherit config from: BaseFormatter
+
+# 
+# c.PlainTextFormatter.type_printers = {}
+
+# 
+# c.PlainTextFormatter.newline = '\n'
+
+# 
+# c.PlainTextFormatter.float_precision = ''
+
+# 
+# c.PlainTextFormatter.verbose = False
+
+# 
+# c.PlainTextFormatter.deferred_printers = {}
+
+# 
+# c.PlainTextFormatter.pprint = True
+
+# 
+# c.PlainTextFormatter.max_width = 79
+
+# 
+# c.PlainTextFormatter.singleton_printers = {}

File dotfiles/.profile

     PATH="/usr/local/bin:${PATH}"
 fi
 
+if [ -d /usr/local/sbin ]; then
+    PATH="/usr/local/sbin:${PATH}"
+fi
+
 if [ -d /usr/local/share/python ] ; then
     PATH="/usr/local/share/python:${PATH}"
 fi