vimrc/sources_non_forked/vim-snippets/snippets/python.snippets

snippet #!
	#!/usr/bin/env python
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}
	"""

snippet wh
	while ${1:condition}:
		${0}
# 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}
# 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}
# New Function
snippet def
	def ${1:fname}(${2:`indent('.') ? 'self' : ''`}):
		"""${3:docstring for $1}"""
		${0}
snippet deff
	def ${1:fname}(${2:`indent('.') ? 'self' : ''`}):
		${0}
# New Method
snippet defs
	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}
snippet el
	else:
		${0}
snippet ei
	elif ${1:condition}:
		${0}
# 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 .
	self.
snippet try Try/Except
	try:
		${1}
	except ${2:Exception}, ${3:e}:
		${0:raise $3}
snippet try Try/Except/Else
	try:
		${1}
	except ${2:Exception}, ${3:e}:
		${4:raise $3}
	else:
		${0}
snippet try Try/Except/Finally
	try:
		${1}
	except ${2:Exception}, ${3:e}:
		${4:raise $3}
	finally:
		${0}
snippet try Try/Except/Else/Finally
	try:
		${1}
	except ${2:Exception}, ${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; pdb.set_trace()
# ipython debugger (ipdb)
snippet ipdb
	import ipdb; ipdb.set_trace()
# ipython debugger (pdbbb)
snippet pdbbb
	import pdbpp; pdbpp.set_trace()
# python console debugger (pudb)
snippet pudb
	import pudb; pudb.set_trace()
snippet pprint
	import pprint; 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}
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
# 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}
	"""