Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
724 lines (541 sloc) 14 KB
priority -50
###########################################################################
# TEXTMATE SNIPPETS #
###########################################################################
#! header
snippet #! "#!/usr/bin/env python" b
#!/usr/bin/env python
$0
endsnippet
snippet "^# ?[uU][tT][fF]-?8" "# encoding: UTF-8" r
# -*- coding: utf-8 -*-
$0
endsnippet
snippet ifmain "ifmain" b
if __name__ == `!p snip.rv = get_quoting_style(snip)`__main__`!p snip.rv = get_quoting_style(snip)`:
${1:${VISUAL:main()}}
endsnippet
snippet with "with" b
with ${1:expr}`!p snip.rv = " as " if t[2] else ""`${2:var}:
${3:${VISUAL:pass}}
$0
endsnippet
snippet for "for loop" b
for ${1:item} in ${2:iterable}:
${3:${VISUAL:pass}}
endsnippet
##########
# COMMON #
##########
# The smart def and smart class snippets use a global option called
# "g:ultisnips_python_style" which, if set to "doxygen" will use doxygen
# style comments in docstrings.
global !p
NORMAL = 0x1
DOXYGEN = 0x2
SPHINX = 0x3
GOOGLE = 0x4
NUMPY = 0x5
JEDI = 0x6
SINGLE_QUOTES = "'"
DOUBLE_QUOTES = '"'
class Arg(object):
def __init__(self, arg):
self.arg = arg
name_and_type = arg.split('=')[0].split(':')
self.name = name_and_type[0].strip()
self.type = name_and_type[1].strip() if len(name_and_type) == 2 else None
def __str__(self):
return self.name
def __unicode__(self):
return self.name
def is_kwarg(self):
return '=' in self.arg
def is_vararg(self):
return '*' in self.name
def get_args(arglist):
args = [Arg(arg) for arg in arglist.split(',') if arg]
args = [arg for arg in args if arg.name != 'self']
return args
def get_quoting_style(snip):
style = snip.opt("g:ultisnips_python_quoting_style", "double")
if style == 'single':
return SINGLE_QUOTES
return DOUBLE_QUOTES
def triple_quotes(snip):
style = snip.opt("g:ultisnips_python_triple_quoting_style")
if not style:
return get_quoting_style(snip) * 3
return (SINGLE_QUOTES if style == 'single' else DOUBLE_QUOTES) * 3
def triple_quotes_handle_trailing(snip, quoting_style):
"""
Generate triple quoted strings and handle any trailing quote char,
which might be there from some autoclose/autopair plugin,
i.e. when expanding ``"|"``.
"""
if not snip.c:
# Do this only once, otherwise the following error would happen:
# RuntimeError: The snippets content did not converge: …
_, col = vim.current.window.cursor
line = vim.current.line
# Handle already existing quote chars after the trigger.
_ret = quoting_style * 3
while True:
try:
nextc = line[col]
except IndexError:
break
if nextc == quoting_style and len(_ret):
_ret = _ret[1:]
col = col+1
else:
break
snip.rv = _ret
else:
snip.rv = snip.c
def get_style(snip):
style = snip.opt("g:ultisnips_python_style", "normal")
if style == "doxygen": return DOXYGEN
elif style == "sphinx": return SPHINX
elif style == "google": return GOOGLE
elif style == "numpy": return NUMPY
elif style == "jedi": return JEDI
else: return NORMAL
def format_arg(arg, style):
if style == DOXYGEN:
return "@param %s TODO" % arg
elif style == SPHINX:
return ":param %s: TODO" % arg
elif style == NORMAL:
return ":%s: TODO" % arg
elif style == GOOGLE:
return "%s (TODO): TODO" % arg
elif style == JEDI:
return ":type %s: TODO" % arg
elif style == NUMPY:
return "%s : TODO" % arg
def format_return(style):
if style == DOXYGEN:
return "@return: TODO"
elif style in (NORMAL, SPHINX, JEDI):
return ":returns: TODO"
elif style == GOOGLE:
return "Returns: TODO"
def write_docstring_args(args, snip):
if not args:
snip.rv += ' {0}'.format(triple_quotes(snip))
return
snip.rv += '\n' + snip.mkline('', indent='')
style = get_style(snip)
if style == GOOGLE:
write_google_docstring_args(args, snip)
elif style == NUMPY:
write_numpy_docstring_args(args, snip)
else:
for arg in args:
snip += format_arg(arg, style)
def write_google_docstring_args(args, snip):
kwargs = [arg for arg in args if arg.is_kwarg()]
args = [arg for arg in args if not arg.is_kwarg()]
if args:
snip += "Args:"
snip.shift()
for arg in args:
snip += format_arg(arg, GOOGLE)
snip.unshift()
snip.rv += '\n' + snip.mkline('', indent='')
if kwargs:
snip += "Kwargs:"
snip.shift()
for kwarg in kwargs:
snip += format_arg(kwarg, GOOGLE)
snip.unshift()
snip.rv += '\n' + snip.mkline('', indent='')
def write_numpy_docstring_args(args, snip):
if args:
snip += "Parameters"
snip += "----------"
kwargs = [arg for arg in args if arg.is_kwarg()]
args = [arg for arg in args if not arg.is_kwarg()]
if args:
for arg in args:
snip += format_arg(arg, NUMPY)
if kwargs:
for kwarg in kwargs:
snip += format_arg(kwarg, NUMPY) + ', optional'
snip.rv += '\n' + snip.mkline('', indent='')
def write_init_body(args, parents, snip):
parents = [p.strip() for p in parents.split(",")]
parents = [p for p in parents if p != 'object']
for p in parents:
snip += p + ".__init__(self)"
if parents:
snip.rv += '\n' + snip.mkline('', indent='')
for arg in filter(lambda arg: not arg.is_vararg(), args):
snip += "self._%s = %s" % (arg, arg)
def write_slots_args(args, snip):
quote = get_quoting_style(snip)
arg_format = quote + '_%s' + quote
args = [arg_format % arg for arg in args]
snip += '__slots__ = (%s,)' % ', '.join(args)
def write_function_docstring(t, snip):
"""
Writes a function docstring with the current style.
:param t: The values of the placeholders
:param snip: UltiSnips.TextObjects.SnippetUtil object instance
"""
snip.rv = ""
snip >> 1
args = get_args(t[2])
if args:
write_docstring_args(args, snip)
style = get_style(snip)
if style == NUMPY:
snip += 'Returns'
snip += '-------'
snip += 'TODO'
else:
snip += format_return(style)
snip.rv += '\n' + snip.mkline('', indent='')
snip += triple_quotes(snip)
def get_dir_and_file_name(snip):
return os.getcwd().split(os.sep)[-1] + '.' + snip.basename
endglobal
########################################
# Class & Special Method Name Snippets #
########################################
snippet class "class with docstrings" b
class ${1:MyClass}(${2:object}):
`!p snip.rv = triple_quotes(snip)`${3:Docstring for $1. }`!p snip.rv = triple_quotes(snip)`
def __init__(self$4):
`!p snip.rv = triple_quotes(snip)`${5:TODO: to be defined.}`!p
snip.rv = ""
snip >> 2
args = get_args(t[4])
write_docstring_args(args, snip)
if args:
snip.rv += '\n' + snip.mkline('', indent='')
snip += '{0}'.format(triple_quotes(snip))
write_init_body(args, t[2], snip)
`
$0
endsnippet
snippet slotclass "class with slots and docstrings" b
class ${1:MyClass}(${2:object}):
`!p snip.rv = triple_quotes(snip)`${3:Docstring for $1. }`!p snip.rv = triple_quotes(snip)`
`!p
snip >> 1
args = get_args(t[4])
write_slots_args(args, snip)
`
def __init__(self$4):
`!p snip.rv = triple_quotes(snip)`${5:TODO: to be defined.}`!p
snip.rv = ""
snip >> 2
args = get_args(t[4])
write_docstring_args(args, snip)
if args:
snip.rv += '\n' + snip.mkline('', indent='')
snip += triple_quotes(snip)
write_init_body(args, t[2], snip)
`
$0
endsnippet
snippet contain "methods for emulating a container type" b
def __len__(self):
${1:pass}
def __getitem__(self, key):
${2:pass}
def __setitem__(self, key, value):
${3:pass}
def __delitem__(self, key):
${4:pass}
def __iter__(self):
${5:pass}
def __reversed__(self):
${6:pass}
def __contains__(self, item):
${7:pass}
endsnippet
snippet context "context manager methods" b
def __enter__(self):
${1:pass}
def __exit__(self, exc_type, exc_value, traceback):
${2:pass}
endsnippet
snippet attr "methods for customizing attribute access" b
def __getattr__(self, name):
${1:pass}
def __setattr__(self, name, value):
${2:pass}
def __delattr__(self, name):
${3:pass}
endsnippet
snippet desc "methods implementing descriptors" b
def __get__(self, instance, owner):
${1:pass}
def __set__(self, instance, value):
${2:pass}
def __delete__(self, instance):
${3:pass}
endsnippet
snippet cmp "methods implementing rich comparison"
def __eq__(self, other):
${1:pass}
def __ne__(self, other):
${2:pass}
def __lt__(self, other):
${3:pass}
def __le__(self, other):
${4:pass}
def __gt__(self, other):
${5:pass}
def __ge__(self, other):
${6:pass}
def __cmp__(self, other):
${7:pass}
endsnippet
snippet repr "methods implementing string representation"
def __repr__(self):
${1:pass}
def __str__(self):
${2:pass}
def __unicode__(self):
${3:pass}
endsnippet
# note: reflected operands and augmented arithmeitc assignements have been
# intentionally ommited to reduce verbosity.
snippet numeric "methods for emulating a numeric type" b
def __add__(self, other):
${1:pass}
def __sub__(self, other):
${2:pass}
def __mul__(self, other):
${3:pass}
def __div__(self, other):
${4:pass}
def __truediv__(self, other):
${5:pass}
def __floordiv__(self, other):
${6:pass}
def __mod__(self, other):
${7:pass}
def __divmod__(self, other):
${8:pass}
def __pow__(self, other):
${9:pass}
def __lshift__(self, other):
${10:pass}
def __rshift__(self, other):
${11:pass}
def __and__(self, other):
${12:pass}
def __xor__(self, other):
${13:pass}
def __or__(self, other):
${14:pass}
def __neg__(self):
${15:pass}
def __pos__(self):
${16:pass}
def __abs__(self):
${17:pass}
def __invert__(self):
${18:pass}
def __complex__(self):
${19:pass}
def __int__(self):
${20:pass}
def __long__(self):
${21:pass}
def __float__(self):
${22:pass}
def __oct__(self):
${22:pass}
def __hex__(self):
${23:pass}
def __index__(self):
${24:pass}
def __coerce__(self, other):
${25:pass}
endsnippet
snippet deff
def ${1:fname}(`!p snip.rv = vim.eval('indent(".") ? "self" : ""')`$2):
$0
endsnippet
snippet def "function with docstrings" b
def ${1:function}(`!p
if snip.indent:
snip.rv = 'self' + (", " if len(t[2]) else "")`${2:arg1}):
`!p snip.rv = triple_quotes(snip)`${4:TODO: Docstring for $1.}`!p
write_function_docstring(t, snip) `
${5:${VISUAL:pass}}
endsnippet
snippet defc "class method with docstrings" b
@classmethod
def ${1:function}(`!p
if snip.indent:
snip.rv = 'cls' + (", " if len(t[2]) else "")`${2:arg1}):
`!p snip.rv = triple_quotes(snip)`${4:TODO: Docstring for $1.}`!p
write_function_docstring(t, snip) `
${5:${VISUAL:pass}}
endsnippet
snippet defs "static method with docstrings" b
@staticmethod
def ${1:function}(${2:arg1}):
`!p snip.rv = triple_quotes(snip)`${4:TODO: Docstring for $1.}`!p
write_function_docstring(t, snip) `
${5:${VISUAL:pass}}
endsnippet
# doesn't expand when there is a word in front
snippet /(^|(?<=\W))\./ "self." r
self.
endsnippet
snippet from "from module import name" b
from ${1:module} import ${2:Stuff}
endsnippet
##############
# PROPERTIES #
##############
snippet roprop "Read Only Property" b
@property
def ${1:name}(self):
${2:return self._$1}$0
endsnippet
snippet rwprop "Read write property" b
def ${1:name}():
`!p snip.rv = triple_quotes(snip) if t[2] else ''
`${2:TODO: Docstring for $1.}`!p
if t[2]:
snip >> 1
style = get_style(snip)
snip.rv += '\n' + snip.mkline('', indent='')
snip += format_return(style)
snip.rv += '\n' + snip.mkline('', indent='')
snip += triple_quotes(snip)
else:
snip.rv = ""`
def fget(self):
return self._$1$0
def fset(self, value):
self._$1 = value
return locals()
$1 = property(**$1(), doc=$1.__doc__)
endsnippet
####################
# If / Else / Elif #
####################
snippet if "If" b
if ${1:condition}:
${2:${VISUAL:pass}}
endsnippet
snippet ife "If / Else" b
if ${1:condition}:
${2:${VISUAL:pass}}
else:
${3:pass}
endsnippet
snippet ifee "If / Elif / Else" b
if ${1:condition}:
${2:${VISUAL:pass}}
elif ${3:condition}:
${4:pass}
else:
${5:pass}
endsnippet
##########################
# Try / Except / Finally #
##########################
snippet try "Try / Except" b
try:
${1:${VISUAL:pass}}
except ${2:Exception} as ${3:e}:
${4:raise $3}
endsnippet
snippet trye "Try / Except / Else" b
try:
${1:${VISUAL:pass}}
except ${2:Exception} as ${3:e}:
${4:raise $3}
else:
${5:pass}
endsnippet
snippet tryf "Try / Except / Finally" b
try:
${1:${VISUAL:pass}}
except ${2:Exception} as ${3:e}:
${4:raise $3}
finally:
${5:pass}
endsnippet
snippet tryef "Try / Except / Else / Finally" b
try:
${1:${VISUAL:pass}}
except${2: ${3:Exception} as ${4:e}}:
${5:raise}
else:
${6:pass}
finally:
${7:pass}
endsnippet
######################
# Assertions & Tests #
######################
snippet ae "Assert equal" b
self.assertEqual(${1:${VISUAL:first}}, ${2:second})
endsnippet
snippet at "Assert True" b
self.assertTrue(${1:${VISUAL:expression}})
endsnippet
snippet af "Assert False" b
self.assertFalse(${1:${VISUAL:expression}})
endsnippet
snippet aae "Assert almost equal" b
self.assertAlmostEqual(${1:${VISUAL:first}}, ${2:second})
endsnippet
snippet ar "Assert raises" b
self.assertRaises(${1:exception}, ${2:${VISUAL:func}}${3/.+/, /}${3:arguments})
endsnippet
snippet an "Assert is None" b
self.assertIsNone(${1:${VISUAL:expression}})
endsnippet
snippet ann "Assert is not None" b
self.assertIsNotNone(${1:${VISUAL:expression}})
endsnippet
snippet testcase "pyunit testcase" b
class Test${1:Class}(${2:unittest.TestCase}):
`!p snip.rv = triple_quotes(snip)`${3:Test case docstring.}`!p snip.rv = triple_quotes(snip)`
def setUp(self):
${4:pass}
def tearDown(self):
${5:pass}
def test_${6:name}(self):
${7:${VISUAL:pass}}
endsnippet
snippet " "triple quoted string (double quotes)" b
"""
${1:${VISUAL:doc}}
`!p triple_quotes_handle_trailing(snip, '"')`
endsnippet
snippet ' "triple quoted string (single quotes)" b
'''
${1:${VISUAL:doc}}
`!p triple_quotes_handle_trailing(snip, "'")`
endsnippet
snippet doc "doc block (triple quotes)"
`!p snip.rv = triple_quotes(snip)`
${1:${VISUAL:doc}}
`!p snip.rv = triple_quotes(snip)`
endsnippet
snippet pmdoc "pocoo style module doc string" b
# -*- coding: utf-8 -*-
"""
`!p snip.rv = get_dir_and_file_name(snip)`
`!p snip.rv = '~' * len(get_dir_and_file_name(snip))`
${1:DESCRIPTION}
:copyright: (c) `date +%Y` by ${2:YOUR_NAME}.
:license: ${3:LICENSE_NAME}, see LICENSE for more details.
"""
$0
endsnippet
# vim:ft=snippets:
You can’t perform that action at this time.