snippet #! #!/usr/bin/env python3 snippet #!2 #!/usr/bin/env python2 # -*- coding: utf-8 -*- snippet #!3 #!/usr/bin/env python3 snippet imp import ${0:module} snippet uni def __unicode__(self): ${0:representation} snippet from from ${1:package} import ${0:module} # Module Docstring snippet docs """ File: ${1:`vim_snippets#Filename('$1.py', 'foo.py')`} Author: `g:snips_author` Email: `g:snips_email` Github: `g:snips_github` Description: ${0} """ # Unittest skip snippet sk "skip unittests" b @unittest.skip(${1:skip_reason}) endsnippet snippet wh while ${1:condition}: ${0:${VISUAL}} # dowh - does the same as do...while in other languages snippet dowh while True: ${1} if ${0:condition}: break snippet with with ${1:expr} as ${2:var}: ${0:${VISUAL}} snippet awith async with ${1:expr} as ${2:var}: ${0:${VISUAL}} # New Class snippet cl class ${1:ClassName}(${2:object}): """${3:docstring for $1}""" def __init__(self, ${4:arg}): ${5:super($1, self).__init__()} self.$4 = $4 ${0} snippet cla class ${1:class_name}: """${0:description}""" snippet clai class ${1:class_name}: """${2:description}""" def __init__(self, ${3:args}): ${0} # New Function snippet def def ${1:fname}(${2:`indent('.') ? 'self' : ''`}): """${3:docstring for $1}""" ${0} snippet deff def ${1:fname}(${2:`indent('.') ? 'self' : ''`}): ${0} snippet adef async def ${1:fname}(${2:`indent('.') ? 'self' : ''`}): """${3:docstring for $1}""" ${0} snippet adeff async def ${1:fname}(${2:`indent('.') ? 'self' : ''`}): ${0} # New Method snippet defi def __init__(self, ${1:args}): ${0} snippet defm def ${1:mname}(self, ${2:arg}): ${0} snippet adefm async def ${1:mname}(self, ${2:arg}): ${0} # New Property snippet property def ${1:foo}(): doc = "${2:The $1 property.}" def fget(self): ${3:return self._$1} def fset(self, value): ${4:self._$1 = value} def fdel(self): ${0:del self._$1} return locals() $1 = property(**$1()) # Ifs snippet if if ${1:condition}: ${0:${VISUAL}} snippet el else: ${0:${VISUAL}} snippet ei elif ${1:condition}: ${0:${VISUAL}} # For snippet for for ${1:item} in ${2:items}: ${0} # Encodes snippet cutf8 # -*- coding: utf-8 -*- snippet clatin1 # -*- coding: latin-1 -*- snippet cascii # -*- coding: ascii -*- # Lambda snippet ld ${1:var} = lambda ${2:vars} : ${0:action} snippet ret return ${0} snippet . self. snippet try Try/Except try: ${1:${VISUAL}} except ${2:Exception} as ${3:e}: ${0:raise $3} snippet trye Try/Except/Else try: ${1:${VISUAL}} except ${2:Exception} as ${3:e}: ${4:raise $3} else: ${0} snippet tryf Try/Except/Finally try: ${1:${VISUAL}} except ${2:Exception} as ${3:e}: ${4:raise $3} finally: ${0} snippet tryef Try/Except/Else/Finally try: ${1:${VISUAL}} except ${2:Exception} as ${3:e}: ${4:raise $3} else: ${5} finally: ${0} # if __name__ == '__main__': snippet ifmain if __name__ == '__main__': ${0:main()} # __magic__ snippet _ __${1:init}__ # python debugger (pdb) snippet pdb __import__('pdb').set_trace() # bpython debugger (bpdb) snippet bpdb __import__('bpdb').set_trace() # ipython debugger (ipdb) snippet ipdb __import__('ipdb').set_trace() # embed ipython itself snippet iem __import__('IPython').embed() # remote python debugger (rpdb) snippet rpdb __import__('rpdb').set_trace() # web python debugger (wdb) snippet wdb __import__('wdb').set_trace() # ptpython snippet ptpython __import__('ptpython.repl', fromlist=('repl')).embed(globals(), locals(), vi_mode=${1:False}, history_filename=${2:None}) # python console debugger (pudb) snippet pudb __import__('pudb').set_trace() # pdb in nosetests snippet nosetrace __import__('nose').tools.set_trace() snippet pprint __import__('pprint').pprint(${1}) snippet " """${0:doc} """ # assertions snippet a= self.assertEqual(${0}, ${1}) # test function/method snippet test def test_${1:description}(${2:`indent('.') ? 'self' : ''`}): ${0} # test case snippet testcase class ${1:ExampleCase}(unittest.TestCase): def test_${2:description}(self): ${0} # test given when then snippet tgwt # given: ${1} # when: ${2} # then: ${3} snippet fut from __future__ import ${0} #getopt snippet getopt try: # Short option syntax: "hv:" # Long option syntax: "help" or "verbose=" opts, args = getopt.getopt(sys.argv[1:], "${1:short_options}", [${2:long_options}]) except getopt.GetoptError, err: # Print debug info print str(err) ${3:error_action} for option, argument in opts: if option in ("-h", "--help"): ${0} elif option in ("-v", "--verbose"): verbose = argument # argparse snippet addp parser = ${VISUAL:argparse.}ArgumentParser() snippet addsp ${0:sub_parser} = parser.add_subparsers().add_parser("${1:name}") snippet addarg parser.add_argument("${0:short_arg}", "${1:long_arg}", default=${2:None}, help="${3:Help text}") snippet addnarg parser.add_argument("${0:arg}", nargs="${1:*}", default"${2:None}, help="${3:Help text}") snippet addaarg parser.add_argument("${0:arg}", "${1:long_arg}", action="${2:store_true}", default=${3:False}, help="${4:Help text}") snippet pargs "${VISUAL:return }"parser.parse_args() # logging # glog = get log snippet glog import logging LOGGER = logging.getLogger(${0:__name__}) snippet le LOGGER.error(${0:msg}) # conflict with lambda=ld, therefor we change into Logger.debuG snippet lg LOGGER.debug(${0:msg}) snippet lw LOGGER.warning(${0:msg}) snippet lc LOGGER.critical(${0:msg}) snippet li LOGGER.info(${0:msg}) snippet epydoc """${1:Description} @param ${2:param}: ${3: Description} @type $2: ${4: Type} @return: ${5: Description} @rtype : ${6: Type} @raise e: ${0: Description} """ snippet dol def ${1:__init__}(self, *args, **kwargs): super(${0:ClassName}, self).$1(*args, **kwargs) snippet kwg self.${1:var_name} = kwargs.get('$1', ${2:None}) snippet lkwg ${1:var_name} = kwargs.get('$1', ${2:None}) snippet args *args${1:,}${0} snippet kwargs **kwargs${1:,}${0} snippet akw *args, **kwargs${1:,}${0} # comprehensions snippet lcp list comprehension [${1} for ${2} in ${3:${VISUAL}}]${0} snippet dcp dict comprehension {${1}: ${2} for ${3} in ${4:${VISUAL}}}${0} snippet scp set comprehension {${1} for ${2} in ${3:${VISUAL}}}${0} 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} snippet context "context manager methods" b def __enter__(self): ${1:pass} def __exit__(self, exc_type, exc_value, traceback): ${2:pass} 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} 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} 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} snippet repr "methods implementing string representation" def __repr__(self): ${1:pass} def __str__(self): ${2:pass} def __unicode__(self): ${3:pass} # 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}