super(${current_class}, self).${current_method}(${cursor})
${superclass}.${current_method}(self${cursor})
if __name__ == '__main__':
${cursor}
if __name__ == '__main__':
${cursor}
import pdb;pdb.set_trace()
import sys;sys.path.append(r'${pydevd_dir_location}')
import pydevd;pydevd.settrace()
import sys;sys.path.append(r'${pydevd_dir_location}')
import pydevd;pydevd.patch_django_autoreload(patch_remote_debugger=True, patch_show_console=True)
def __eq__(self, o):
if isinstance(o, ${current_class}):
${pass}${cursor}
return False
def __ne__(self, o):
return not self == o
class ${class}(${object}):${cursor}
class ${class}:${cursor}
def ${method}(self):${cursor}
def __init__(self):${cursor}
def __init__(self, ${params}):${cursor}
def ${method}(self, ${params}):${cursor}
def ${method}():${cursor}
print${space_if_py2}${lparen_if_py3}${cursor}${rparen_if_py3}
print${space_if_py2}${lparen_if_py3}'\n'.join(sorted(dir(${cursor})))${rparen_if_py3}
import traceback;traceback.print_exc()${cursor}
raise RuntimeError('${desc}')${cursor}
raise ${cursor}
import unittest
class ${TestCase}(unittest.TestCase):
def setUp(self):
unittest.TestCase.setUp(self)
def tearDown(self):
unittest.TestCase.tearDown(self)
def test${Met1}(self):
${pass}${cursor}
if __name__ == '__main__':
unittest.main()
and ${cursor}
assert ${cursor}
break${cursor}
continue${cursor}
del ${cursor}
elif${cursor}
else${cursor}
for ${cursor}:
from ${cursor}
global ${cursor}
import ${cursor}
lambda ${args}:${cursor}
not ${cursor}
pass${cursor}
return ${cursor}
while ${cursor}:
yield ${cursor}
def ${prop}(): #@NoSelf
doc = """${Docstring}""" #@UnusedVariable
def fget(self):
return self._${prop}
def fset(self, value):
self._${prop} = value
def fdel(self):
del self._${prop}
return locals()
${prop} = property(**${prop}())${cursor}
'''
Created on ${date}
@author: ${user}
'''
import unittest
class Test(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test${Name}(self):
${pass}${cursor}
if __name__ == "__main__":
#import sys;sys.argv = ['', 'Test.test${Name}']
unittest.main()
'''
Created on ${date}
@author: ${user}
'''
if __name__ == '__main__':
${pass}${cursor}
'''
Created on ${date}
@author: ${user}
'''
class ${MyClass}(${object}):
'''
${classdocs}
'''
def __init__(self, ${params}):
'''
${Constructor}
'''
${cursor}
'''
Created on ${date}
@author: ${user}
'''
${cursor}
'''
Created on ${date}
@author: ${user}
'''
import unittest
class Test(unittest.TestCase):
def test${Name}(self):
${pass}${cursor}
if __name__ == "__main__":
#import sys;sys.argv = ['', 'Test.test${Name}']
unittest.main()
#!/usr/local/bin/python2.7
# encoding: utf-8
'''
${module} -- ${shortdesc}
${module} is a ${description}
It defines ${classes_and_methods}
@author: ${user_name}
@copyright: ${year} ${organization_name}. All rights reserved.
@license: ${license}
@contact: ${user_email}
@deffield updated: Updated
'''
import sys
import os
from argparse import ArgumentParser
from argparse import RawDescriptionHelpFormatter
__all__ = []
__version__ = 0.1
__date__ = '${isodate}'
__updated__ = '${isodate}'
DEBUG = 1
TESTRUN = 0
PROFILE = 0
class CLIError(Exception):
'''Generic exception to raise and log different fatal errors.'''
def __init__(self, msg):
super(CLIError).__init__(type(self))
self.msg = "E: %s" % msg
def __str__(self):
return self.msg
def __unicode__(self):
return self.msg
def main(argv=None): # IGNORE:C0111
'''Command line options.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date)
program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
program_license = '''%s
Created by ${user_name} on %s.
Copyright ${year} ${organization_name}. All rights reserved.
Licensed under the Apache License 2.0
http://www.apache.org/licenses/LICENSE-2.0
Distributed on an "AS IS" basis without warranties
or conditions of any kind, either express or implied.
USAGE
''' % (program_shortdesc, str(__date__))
try:
# Setup argument parser
parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter)
parser.add_argument("-r", "--recursive", dest="recurse", action="store_true", help="recurse into subfolders [default: %(default)s]")
parser.add_argument("-v", "--verbose", dest="verbose", action="count", help="set verbosity level [default: %(default)s]")
parser.add_argument("-i", "--include", dest="include", help="only include paths matching this regex pattern. Note: exclude is given preference over include. [default: %(default)s]", metavar="RE" )
parser.add_argument("-e", "--exclude", dest="exclude", help="exclude paths matching this regex pattern. [default: %(default)s]", metavar="RE" )
parser.add_argument('-V', '--version', action='version', version=program_version_message)
parser.add_argument(dest="paths", help="paths to folder(s) with source file(s) [default: %(default)s]", metavar="path", nargs='+')
# Process arguments
args = parser.parse_args()
paths = args.paths
verbose = args.verbose
recurse = args.recurse
inpat = args.include
expat = args.exclude
if verbose > 0:
print("Verbose mode on")
if recurse:
print("Recursive mode on")
else:
print("Recursive mode off")
if inpat and expat and inpat == expat:
raise CLIError("include and exclude pattern are equal! Nothing will be processed.")
for inpath in paths:
### do something with inpath ###
print(inpath)
return 0
except KeyboardInterrupt:
### handle keyboard interrupt ###
return 0
except Exception, e:
if DEBUG or TESTRUN:
raise(e)
indent = len(program_name) * " "
sys.stderr.write(program_name + ": " + repr(e) + "\n")
sys.stderr.write(indent + " for help use --help")
return 2
if __name__ == "__main__":
if DEBUG:
sys.argv.append("-h")
sys.argv.append("-v")
sys.argv.append("-r")
if TESTRUN:
import doctest
doctest.testmod()
if PROFILE:
import cProfile
import pstats
profile_filename = '${module}_profile.txt'
cProfile.run('main()', profile_filename)
statsfile = open("profile_stats.txt", "wb")
p = pstats.Stats(profile_filename, stream=statsfile)
stats = p.strip_dirs().sort_stats('cumulative')
stats.print_stats()
statsfile.close()
sys.exit(0)
sys.exit(main())
#!/usr/bin/env python
# encoding: utf-8
'''
${module} -- ${shortdesc}
${module} is a ${description}
It defines ${classes_and_methods}
@author: ${user_name}
@copyright: ${year} ${organization_name}. All rights reserved.
@license: ${license}
@contact: ${user_email}
@deffield updated: Updated
'''
import sys
import os
from optparse import OptionParser
__all__ = []
__version__ = 0.1
__date__ = '${isodate}'
__updated__ = '${isodate}'
DEBUG = 1
TESTRUN = 0
PROFILE = 0
def main(argv=None):
'''Command line options.'''
program_name = os.path.basename(sys.argv[0])
program_version = "v0.1"
program_build_date = "%s" % __updated__
program_version_string = '%%prog %s (%s)' % (program_version, program_build_date)
#program_usage = '''usage: spam two eggs''' # optional - will be autogenerated by optparse
program_longdesc = '''''' # optional - give further explanation about what the program does
program_license = "Copyright ${year} ${user_name} (${organization_name}) \
Licensed under the Apache License 2.0\nhttp://www.apache.org/licenses/LICENSE-2.0"
if argv is None:
argv = sys.argv[1:]
try:
# setup option parser
parser = OptionParser(version=program_version_string, epilog=program_longdesc, description=program_license)
parser.add_option("-i", "--in", dest="infile", help="set input path [default: %default]", metavar="FILE")
parser.add_option("-o", "--out", dest="outfile", help="set output path [default: %default]", metavar="FILE")
parser.add_option("-v", "--verbose", dest="verbose", action="count", help="set verbosity level [default: %default]")
# set defaults
parser.set_defaults(outfile="./out.txt", infile="./in.txt")
# process options
(opts, args) = parser.parse_args(argv)
if opts.verbose > 0:
print("verbosity level = %d" % opts.verbose)
if opts.infile:
print("infile = %s" % opts.infile)
if opts.outfile:
print("outfile = %s" % opts.outfile)
# MAIN BODY #
except Exception, e:
indent = len(program_name) * " "
sys.stderr.write(program_name + ": " + repr(e) + "\n")
sys.stderr.write(indent + " for help use --help")
return 2
if __name__ == "__main__":
if DEBUG:
sys.argv.append("-h")
if TESTRUN:
import doctest
doctest.testmod()
if PROFILE:
import cProfile
import pstats
profile_filename = '${module}_profile.txt'
cProfile.run('main()', profile_filename)
statsfile = open("profile_stats.txt", "wb")
p = pstats.Stats(profile_filename, stream=statsfile)
stats = p.strip_dirs().sort_stats('cumulative')
stats.print_stats()
statsfile.close()
sys.exit(0)
sys.exit(main())