Пример #1
0
def get_opt_parser():
    # use module docstring for help output
    p = OptionParser(
        usage="%s [OPTIONS] <DIRECTORY CONTAINING DICOMSs> <mount point>" %
        os.path.basename(sys.argv[0]),
        version="%prog " + nib.__version__)

    p.add_options([
        Option("-v",
               "--verbose",
               action="count",
               dest="verbose",
               default=0,
               help="make noise.  Could be specified multiple times"),
    ])

    p.add_options([
        Option("-L",
               "--follow-links",
               action="store_true",
               dest="followlinks",
               default=False,
               help="Follow symbolic links in DICOM directory"),
    ])
    return p
Пример #2
0
def main():
    global opts
    (progdir, progname) = os.path.split(sys.argv[0])

    usage = "usage: %prog [options] [stl file]"
    parser = OptionParser(usage=usage)
    parser.disable_interspersed_args()
    parser.add_options(options)
    (opts, args) = parser.parse_args()

    filename = None
    if len(args):
        filename = args[0]
    a = stltool.stl(filename)
    (points, faces) = a.unique_vertices(a.facets)

    if opts.boundary:
        (pxmin, pymin, pxmax, pymax) = map(float, opts.boundary.split(','))

    x = np.array(map(lambda p: p[0], points))
    y = np.array(map(lambda p: p[1], points))
    z = np.array(map(lambda p: p[2], points))

    fig = pp.figure()
    if opts.boundary:
        pp.axis([pxmin, pxmax, pymin, pymax])
    pp.tricontourf(x, y, z, 256)
    pp.colorbar()
    pp.triplot(x, y, faces, 'wo-')
    pp.title('Correction mesh contour')
    pp.show()
def get_parser():
    parser = OptionParser()
    parser.add_options(cone_common.COMMON_OPTIONS)
    parser.add_option("-c", "--configuration",
                        dest="configs",
                        action="append",
                        help="Defines the name of the configuration for the action, can be "\
                             "specified multiple times to include multiple configurations.",
                        metavar="CONFIG",
                        default=[])

    parser.add_option("--config-wildcard",
                      action="append",
                      dest="config_wildcards",
                      help="Wildcard pattern for including configurations, e.g. "\
                           "product_langpack_*_root.confml",
                      metavar="WILDCARD",
                      default=[])

    parser.add_option("--config-regex",
                      action="append",
                      dest="config_regexes",
                      help="Regular expression for including configurations, e.g. "\
                           "product_langpack_\\d{2}_root.confml",
                      metavar="REGEX",
                      default=[])

    parser.add_option("-p", "--project",\
                       dest="project",\
                       help="defines the location of current project. Default is the current working directory.",\
                       default=".",\
                       metavar="STORAGE")
    return parser
Пример #4
0
def get_opt_parser():
    # use module docstring for help output
    p = OptionParser(
        usage="%s [OPTIONS] [FILE ...]\n\n" % sys.argv[0] + __doc__,
        version="%prog " + nib.__version__)

    p.add_options([
        Option("-v", "--verbose", action="count",
               dest="verbose", default=0,
               help="Make more noise.  Could be specified multiple times"),

        Option("-H", "--header-fields",
               dest="header_fields", default='',
               help="Header fields (comma separated) to be printed as well (if present)"),

        Option("-s", "--stats",
               action="store_true", dest='stats', default=False,
               help="Output basic data statistics"),

        Option("-c", "--counts",
               action="store_true", dest='counts', default=False,
               help="Output counts - number of entries for each numeric value "
                    "(useful for int ROI maps)"),

        Option("--all-counts",
               action="store_true", dest='all_counts', default=False,
               help="Output all counts, even if number of unique values > %d" % MAX_UNIQUE),

        Option("-z", "--zeros",
               action="store_true", dest='stats_zeros', default=False,
               help="Include zeros into output basic data statistics (--stats, --counts)"),
    ])

    return p
Пример #5
0
def main():
    parser = OptionParser(usage="%s PATH_TO_ANALYZE\n\n" % sys.argv[0] +
                          __doc__,
                          version="%prog " + __version__)
    parser.add_options([
        Option("-L",
               "--lib-path",
               action="store",
               type='string',
               help="Output subdirectory path to copy library dependencies"),
        Option("-d",
               "--dylibs-only",
               action="store_true",
               help="Only analyze files with known dynamic library "
               "extensions")
    ])
    (opts, paths) = parser.parse_args()
    if len(paths) < 1:
        parser.print_help()
        sys.exit(1)

    if opts.lib_path is None:
        opts.lib_path = '.dylibs'
    lib_filt_func = 'dylibs-only' if opts.dylibs_only else None
    multi = len(paths) > 1
    for path in paths:
        if multi:
            print(path)
        # evaluate paths relative to the path we are working on
        lib_path = os.path.join(path, opts.lib_path)
        delocate_path(path, lib_path, lib_filt_func)
Пример #6
0
	def main():
		options = [
			Option('-d', '--dontcares', dest='dc', default='',
				help='comma-separated don\'t-cares', metavar='D'),
			Option('-o', '--ones', dest='ones', default='',
				help='comma-separated ones', metavar='O'),
			Option('-z', '--zeros', dest='zeros', default='',
				help='comma-separated zeros', metavar='Z')
		]

		f = IndentedHelpFormatter()
		def raw_format(s): return s + '\n'
		f.format_description = raw_format

		optparser = OptionParser(description=__doc__, formatter=f)
		optparser.add_options(options)
		opts, args = optparser.parse_args()
		if len(sys.argv) == 1 or args:
			optparser.print_help()
			exit()
		
		opts.dc = [int(i) for i in opts.dc.split(',') if i]
		opts.ones = [int(i) for i in opts.ones.split(',') if i]
		opts.zeros = [int(i) for i in opts.zeros.split(',') if i]
	
		soln = qm(dc=opts.dc, ones=opts.ones, zeros=opts.zeros)
		if len(soln) == 0:
			sys.stdout.write('contradiction\n')
		elif len(soln) == 1 and soln[0].count('X') == len(soln[0]):
			sys.stdout.write('tautology\n')
		else:
			sys.stdout.write(' '.join(soln) + '\n')
Пример #7
0
    def _parse_args(self):
        parser = OptionParser()
        parser.add_options(self.option_list)
        self.options, _ = parser.parse_args()
        if self.options.download_perm_group:
            try:
                self.download_perm_groups = []
                for group in self.options.download_perm_group.split(','):
                    self.download_perm_groups.append(
                        Group.objects.get(name=group)
                    )
            except Group.DoesNotExist:
                raise SystemExit('The download permissions group doesn\'t exist')
        else:
            self.download_perm_groups = []

        try:
            self.owner_group = Group.objects.get(name=self.options.owner_group)
        except Group.DoesNotExist:
            raise SystemExit('The owner group specified doesn\'t exist')

        try:
            self.upload_user = User.objects.get(username=self.options.upload_user)
        except User.DoesNotExist:
            raise SystemExit('The upload user specified doesn\'t exist')
Пример #8
0
def main():
    global opts
    (progdir, progname) = os.path.split(sys.argv[0])

    usage = "usage: %prog [options] file.stl"
    parser = OptionParser(usage=usage)
    parser.disable_interspersed_args()
    parser.add_options(options)
    (opts, args) = parser.parse_args()

    points = readpoints()

    if opts.inifile:
        import linuxcnc
        inifile = linuxcnc.ini(opts.inifile)
        lu = inifile.find("TRAJ", "LINEAR_UNITS")
        if lu.lower() in ("mm", "metric"):
            units = 1.0
        else:
            units = 25.4
        xmin = float(inifile.find("AXIS_0", "MIN_LIMIT")) * units
        ymin = float(inifile.find("AXIS_1", "MIN_LIMIT")) * units
        xmax = float(inifile.find("AXIS_0", "MAX_LIMIT")) * units
        ymax = float(inifile.find("AXIS_1", "MAX_LIMIT")) * units
        zbound = 0
        if opts.zbound:
            zbound = opts.zbound
        points.append(Point(xmin, ymin, zbound))
        points.append(Point(xmax, ymax, zbound))
        points.append(Point(xmin, ymax, zbound))
        points.append(Point(xmax, ymin, zbound))

    triangles = voronoi.computeDelaunayTriangulation(points)
    stldump(sys.stdout, points, triangles)
Пример #9
0
    def _parse_args(self):
        parser = OptionParser()
        parser.add_options(self.option_list)
        self.options, _ = parser.parse_args()
        if self.options.download_perm_group:
            try:
                self.download_perm_groups = []
                for group in self.options.download_perm_group.split(','):
                    self.download_perm_groups.append(
                        Group.objects.get(name=group))
            except Group.DoesNotExist:
                raise SystemExit(
                    'The download permissions group doesn\'t exist')
        else:
            self.download_perm_groups = []

        try:
            self.owner_group = Group.objects.get(name=self.options.owner_group)
        except Group.DoesNotExist:
            raise SystemExit('The owner group specified doesn\'t exist')

        try:
            self.upload_user = User.objects.get(
                username=self.options.upload_user)
        except User.DoesNotExist:
            raise SystemExit('The upload user specified doesn\'t exist')
Пример #10
0
def main():
    """ creates a HAL component.
        parsees a glade XML file with gtk.builder or libglade
        calls gladevcp.makepins with the specified XML file
        to create pins and register callbacks.
        main window must be called "window1"
    """
    global gladevcp_debug
    (progdir, progname) = os.path.split(sys.argv[0])

    usage = "usage: %prog [options] myfile.ui"
    parser = OptionParser(usage=usage)
    parser.disable_interspersed_args()
    parser.add_options(options)

    (opts, args) = parser.parse_args()

    if not args:
        parser.print_help()
        sys.exit(1)
    
    BASE = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), ".."))
    libdir = os.path.join(BASE, "lib", "python")
    sys.path.append(libdir)
    arhmidir = os.path.join(BASE, "lib", "python", "arhmi")
    sys.path.append(arhmidir)
    
    gladevcp_debug = debug = opts.debug
    xmlname = args[0]

    #if there was no component name specified use the xml file name
    if opts.component is None:
        opts.component = os.path.splitext(os.path.basename(xmlname))[0]

    builder = gtk.Builder()
    # try loading as a gtk.builder project
    try:
        builder.add_from_file(xmlname)
    except:
#         #try loading as a libglade project
#         try:
#             dbg("**** GLADE VCP INFO:    Not a GtkBuilder project, trying to load as a GTK builder project")
#             builder = gtk.glade.XML(xmlname)
#             builder = GladeBuilder(builder)
        try:
            # for arhmi applications
            LOCALEDIR = os.path.join(BASE, "share", "locale")
            o = "plasma"
            gettext.install(o, localedir=LOCALEDIR, unicode=True)
            gtk.glade.bindtextdomain(o, LOCALEDIR)
            gtk.glade.textdomain(o)
            
            base = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), ".."))
            sharedir = os.path.join(base, "share", "linuxcnc")
            gladefile = os.path.join(sharedir, xmlname)
            builder.add_from_file(gladefile)
        except Exception,e:
            print >> sys.stderr, "**** GLADE VCP ERROR:    With xml file: %s : %s" % (xmlname, e)
            sys.exit(0)
Пример #11
0
def main():
    """
    The main function.

    @author: Marco Wegner
    """

    usage = "usage: %prog [options] template1 [template2, ...]"
    parser = OptionParser(usage, conflict_handler="resolve")
    parser.add_options(support.get_global_options())
    parser.add_options(_get_local_options())

    (options, args) = parser.parse_args()

    # the script has been called without any options or arguments
    if len(sys.argv) == 1:
        parser.print_help()
        sys.exit()

    delimiters = support.extract_delimiters(options)

    # check if the template file is defined
    if len(args) == 0:
        support.print_error_message("no template file(s) specified")
        sys.exit()

    if options.verbose:
        print "\nExtracting translatable strings from the template files:"

    super_store = UT3Store()

    count = 0
    for tmpl_file in args:
        tmpl = UT3Template(tmpl_file, delimiters)
        tmpl_store = tmpl.parse()
        num_rem = len(tmpl_store.get_all())
        count = count + num_rem

        super_store.extend(tmpl_store)

        if options.verbose:
            tname = os.path.basename(tmpl_file)
            print " * " + tname + ": " + str(num_rem) + " messages"

    if options.verbose:
        num_rem = len(super_store.get_all())
        print "\nHandling duplicates: removing %i strings" % (count - num_rem)
        print "\nRemaining to be written: %i strings" % (num_rem)
        print "\nWriting the template...\n"

    pofile = Ut3PoFile(options.outfile)
    pofile.write(super_store, True)

    if options.verbose:
        print "\nDone."

    return
Пример #12
0
Файл: go.py Проект: yacoob/go
def initFromCmdLine():
    """ Initialize application according to commandline flags."""
    app = {}
    data_dir = resource_filename(__name__, '')
    # parse command line
    parser = OptionParser()
    option_list = [
        make_option(
            '-D',
            '--debug',
            action='store_true',
            dest='debug',
            help='enable Bottle debug mode [false]',
        ),
        make_option(
            '-n',
            '--nofork',
            action='store_true',
            dest='nofork',
            help='do not daemonize at start [false]',
        ),
        make_option(
            '-d',
            '--db-dir',
            dest='db_dir',
            help='directory for dbs [/tmp]',
        ),
        make_option(
            '-a',
            '--data-dir',
            dest='data_dir',
            help='prefix for data directories [%s]' %
            data_dir,
        ),
        make_option(
            '-H',
            '--host',
            dest='host',
            help='hostname to bind on [localhost]',
        ),
        make_option(
            '-p',
            '--port',
            type='int',
            dest='port',
            help='port to bind to [8080]',
        ),
    ]
    parser.add_options(option_list)
    parser.set_defaults(
        debug=False, nofork=False,
        host='localhost', port=8080,
    )

    options = parser.parse_args()[0]
    app.update(vars(options))
    return app
Пример #13
0
    def __init__(self):
        
        usage = "usage: %prog [options]"
        parser = OptionParser(usage=usage)
        parser.disable_interspersed_args()
        parser.add_options(options)
        self.set_theme_font()
        (opts, args) = parser.parse_args()

        self.window = gtk.Window()
        self.window.set_default_size(1024, 600)
        
        xid = None
        if opts.parent:
            xid = int(opts.parent)
            plug = gtk.Plug(xid)
            for c in self.window.get_children():
                self.window.remove(c)
                plug.add(c)
            self.window = plug

        self.window.connect('destroy', self.quit)
        
        self.table = gtk.Table(10,5)
        
        self.btn_hal= gtk.Button(label="HAL Configuration")
        self.btn_hal.set_border_width(4)
        self.btn_hal.connect("clicked", self.halshow_action)

        self.btn_halscope= gtk.Button(label="HAL Scope")
        self.btn_halscope.set_border_width(4)
        self.btn_halscope.connect("clicked", self.halscope_action)

        self.btn_ladder = gtk.Button(label="Ladder Logic")
        self.btn_ladder.set_border_width(4)
        self.btn_ladder.connect("clicked", self.ladder_action)

        self.btn_teamviewer = gtk.Button(label="Teamviewer")
        self.btn_teamviewer.set_border_width(4)
        self.btn_teamviewer.connect("clicked", self.teamviewer_action)
        
        self.btn_nautilus = gtk.Button(label="File Manager")
        self.btn_nautilus.set_border_width(4)
        self.btn_nautilus.connect("clicked", self.nautilus_action)

        self.btn_linuxcncop = gtk.Button(label="Linuxcnc Status")
        self.btn_linuxcncop.set_border_width(4)
        self.btn_linuxcncop.connect("clicked", self.linuxcnc_status)
        
        self.table.attach(self.btn_hal,         0, 1, 0, 1)
        self.table.attach(self.btn_ladder,      0, 1, 1, 2)
        self.table.attach(self.btn_linuxcncop,  0, 1, 2, 3)
        self.table.attach(self.btn_halscope,    1, 2, 0, 1)
        self.table.attach(self.btn_teamviewer,  1, 2, 1, 2)
        self.table.attach(self.btn_nautilus,    1, 2, 2, 3)
        self.window.add(self.table)
Пример #14
0
    def __init__(self):

        usage = "usage: %prog [options]"
        parser = OptionParser(usage=usage)
        parser.disable_interspersed_args()
        parser.add_options(options)
        self.set_theme_font()
        (opts, args) = parser.parse_args()

        self.window = gtk.Window()
        self.window.set_default_size(1024, 600)

        xid = None
        if opts.parent:
            xid = int(opts.parent)
            plug = gtk.Plug(xid)
            for c in self.window.get_children():
                self.window.remove(c)
                plug.add(c)
            self.window = plug

        self.window.connect('destroy', self.quit)

        self.table = gtk.Table(10, 5)

        self.btn_hal = gtk.Button(label="HAL Configuration")
        self.btn_hal.set_border_width(4)
        self.btn_hal.connect("clicked", self.halshow_action)

        self.btn_halscope = gtk.Button(label="HAL Scope")
        self.btn_halscope.set_border_width(4)
        self.btn_halscope.connect("clicked", self.halscope_action)

        self.btn_ladder = gtk.Button(label="Ladder Logic")
        self.btn_ladder.set_border_width(4)
        self.btn_ladder.connect("clicked", self.ladder_action)

        self.btn_teamviewer = gtk.Button(label="Teamviewer")
        self.btn_teamviewer.set_border_width(4)
        self.btn_teamviewer.connect("clicked", self.teamviewer_action)

        self.btn_nautilus = gtk.Button(label="File Manager")
        self.btn_nautilus.set_border_width(4)
        self.btn_nautilus.connect("clicked", self.nautilus_action)

        self.btn_linuxcncop = gtk.Button(label="Linuxcnc Status")
        self.btn_linuxcncop.set_border_width(4)
        self.btn_linuxcncop.connect("clicked", self.linuxcnc_status)

        self.table.attach(self.btn_hal, 0, 1, 0, 1)
        self.table.attach(self.btn_ladder, 0, 1, 1, 2)
        self.table.attach(self.btn_linuxcncop, 0, 1, 2, 3)
        self.table.attach(self.btn_halscope, 1, 2, 0, 1)
        self.table.attach(self.btn_teamviewer, 1, 2, 1, 2)
        self.table.attach(self.btn_nautilus, 1, 2, 2, 3)
        self.window.add(self.table)
Пример #15
0
def main():
    parser = OptionParser(
        usage="%s PATH_TO_ANALYZE\n\n" % sys.argv[0] + __doc__,
        version="%prog " + __version__,
    )
    parser.add_options([
        Option(
            "-L",
            "--lib-path",
            action="store",
            type="string",
            help="Output subdirectory path to copy library dependencies",
        ),
        Option(
            "-d",
            "--dylibs-only",
            action="store_true",
            help="Only analyze files with known dynamic library extensions",
        ),
        Option(
            "--executable-path",
            action="store",
            type="string",
            default=os.path.dirname(sys.executable),
            help=("The path used to resolve @executable_path in dependencies"),
        ),
        Option(
            "--ignore-missing-dependencies",
            action="store_true",
            help=("Skip dependencies which couldn't be found and delocate "
                  "as much as possible"),
        ),
    ])
    (opts, paths) = parser.parse_args()
    if len(paths) < 1:
        parser.print_help()
        sys.exit(1)

    if opts.lib_path is None:
        opts.lib_path = ".dylibs"
    lib_filt_func = "dylibs-only" if opts.dylibs_only else None
    multi = len(paths) > 1
    for path in paths:
        if multi:
            print(path)
        # evaluate paths relative to the path we are working on
        lib_path = os.path.join(path, opts.lib_path)
        delocate_path(
            path,
            lib_path,
            lib_filt_func,
            executable_path=opts.executable_path,
            ignore_missing=opts.ignore_missing_dependencies,
        )
Пример #16
0
def main():
    parser = OptionParser(
        usage="%s WHEEL_OR_PATH_TO_ANALYZE\n\n" % sys.argv[0] + __doc__,
        version="%prog " + __version__,
    )
    parser.add_options([
        Option(
            "-a",
            "--all",
            action="store_true",
            help="Show all dependencies, including system libs",
        ),
        Option(
            "-d",
            "--depending",
            action="store_true",
            help="Show libraries depending on dependencies",
        ),
    ])
    (opts, paths) = parser.parse_args()
    if len(paths) < 1:
        parser.print_help()
        sys.exit(1)

    multi = len(paths) > 1
    for path in paths:
        if multi:
            print(path + ":")
            indent = "   "
        else:
            indent = ""
        if isdir(path):
            lib_dict = tree_libs_from_directory(path, ignore_missing=True)
            lib_dict = stripped_lib_dict(lib_dict, realpath(getcwd()) + psep)
        else:
            lib_dict = wheel_libs(path, ignore_missing=True)
        keys = sorted(lib_dict)
        if not opts.all:
            keys = [key for key in keys if filter_system_libs(key)]
        if not opts.depending:
            if len(keys):
                print(indent + ("\n" + indent).join(keys))
            continue
        i2 = indent + "    "
        for key in keys:
            print(indent + key + ":")
            libs = lib_dict[key]
            if len(libs):
                print(i2 + ("\n" + i2).join(libs))
Пример #17
0
def main():
    """ creates a HAL component.
        parsees a glade XML file with gtk.builder or libglade
        calls gladevcp.makepins with the specified XML file
        to create pins and register callbacks.
        main window must be called "window1"
    """
    global gladevcp_debug
    (progdir, progname) = os.path.split(sys.argv[0])

    usage = "usage: %prog [options] myfile.ui"
    parser = OptionParser(usage=usage)
    parser.disable_interspersed_args()
    parser.add_options(options)

    (opts, args) = parser.parse_args()

    if not args:
        parser.print_help()
        sys.exit(1)

    gladevcp_debug = debug = opts.debug
    xmlname = args[0]

    if opts.instance > -1 and not remote_ok:
        print >> sys.stderr, "gladevcp: cant operate remotely  - modules missing"
        sys.exit(1)

    #if there was no component name specified use the xml file name
    if opts.component is None:
        opts.component = os.path.splitext(os.path.basename(xmlname))[0]

    #try loading as a libglade project
    try:
        builder = gtk.Builder()
        builder.add_from_file(xmlname)
    except:
        try:
            # try loading as a gtk.builder project
            dbg("**** GLADE VCP INFO:    Not a builder project, trying to load as a lib glade project"
                )
            builder = gtk.glade.XML(xmlname)
            builder = GladeBuilder(builder)

        except Exception, e:
            print >> sys.stderr, "**** GLADE VCP ERROR:    With xml file: %s : %s" % (
                xmlname, e)
            sys.exit(0)
Пример #18
0
def mainparser(harvest=None,with_stdopts=True,**kwargs):
  """setup option parser"""
  from optparse import OptionParser

  kwargs.setdefault('usage','usage: %prog [options] [file(s)]')
  kwargs.setdefault('version','%prog ' + __version__)
  parser = OptionParser(**kwargs)
  parser.set_conflict_handler('resolve')
      
  if with_stdopts:
    parser.add_options(stdopts)

  if harvest is not None:
    for optlist in harvest_options(harvest):
      parser.add_options(optlist)

  return parser
Пример #19
0
def main():
    """ creates a HAL component.
        parsees a glade XML file with gtk.builder or libglade
        calls gladevcp.makepins with the specified XML file
        to create pins and register callbacks.
        main window must be called "window1"
    """
    global gladevcp_debug
    (progdir, progname) = os.path.split(sys.argv[0])

    usage = "usage: %prog [options] myfile.ui"
    parser = OptionParser(usage=usage)
    parser.disable_interspersed_args()
    parser.add_options(options)

    (opts, args) = parser.parse_args()

    if not args:
        parser.print_help()
        sys.exit(1)

    gladevcp_debug = debug = opts.debug
    xmlname = args[0]

    if opts.instance > -1 and not remote_ok:
        print >> sys.stderr, "gladevcp: cant operate remotely  - modules missing"
        sys.exit(1)

    #if there was no component name specified use the xml file name
    if opts.component is None:
        opts.component = os.path.splitext(os.path.basename(xmlname))[0]

    #try loading as a libglade project
    try:
        builder = gtk.Builder()
        builder.add_from_file(xmlname)
    except:
        try:
            # try loading as a gtk.builder project
            dbg("**** GLADE VCP INFO:    Not a builder project, trying to load as a lib glade project")
            builder = gtk.glade.XML(xmlname)
            builder = GladeBuilder(builder)

        except Exception,e:
            print >> sys.stderr, "**** GLADE VCP ERROR:    With xml file: %s : %s" % (xmlname,e)
            sys.exit(0)
Пример #20
0
def get_opt_parser():
    # use module docstring for help output
    p = OptionParser(usage="%s [OPTIONS] [FILE ...]\n\n" % sys.argv[0] +
                     __doc__,
                     version="%prog " + nib.__version__)

    p.add_options([
        Option("-v",
               "--verbose",
               action="count",
               dest="verbose",
               default=0,
               help="Make more noise.  Could be specified multiple times"),
        Option("-H",
               "--header-fields",
               dest="header_fields",
               default='all',
               help="Header fields (comma separated) to be printed as well"
               " (if present)"),
        Option("--ma",
               "--data-max-abs-diff",
               dest="data_max_abs_diff",
               type=float,
               default=0.0,
               help="Maximal absolute difference in data between files"
               " to tolerate."),
        Option("--mr",
               "--data-max-rel-diff",
               dest="data_max_rel_diff",
               type=float,
               default=0.0,
               help="Maximal relative difference in data between files to"
               " tolerate. If --data-max-abs-diff is also specified,"
               " only the data points with absolute difference greater"
               " than that value would be considered for relative"
               " difference check."),
        Option("--dt",
               "--datatype",
               dest="dtype",
               default=np.float64,
               help="Enter a numpy datatype such as 'float32'.")
    ])

    return p
Пример #21
0
def get_opt_parser():
    # use module docstring for help output
    p = OptionParser(
        usage="%s [OPTIONS] <DIRECTORY CONTAINING DICOMSs> <mount point>"
              % os.path.basename(sys.argv[0]),
        version="%prog " + nib.__version__)

    p.add_options([
        Option("-v", "--verbose", action="count",
               dest="verbose", default=0,
               help="make noise.  Could be specified multiple times"),
    ])

    p.add_options([
        Option("-L", "--follow-links", action="store_true",
               dest="followlinks", default=False,
               help="Follow symbolic links in DICOM directory"),
    ])
    return p
Пример #22
0
def main():
    usage = "usage: %prog [options] expression"
    parser = OptionParser(usage=usage)
    parser.disable_interspersed_args()
    parser.add_options(options)

    (opts, args) = parser.parse_args()

    if not args:
        parser.print_help()
        print("examples:")
        print("  lut5 'i0 &  i1 &  i2 &  i3 &  i4'")
        print("  lut5 'i0 |  i1 |  i2 |  i3 |  i4'")
        print("  lut5 -n2 'i0 ^  i1'")
        print("# a two-line mux:")
        print("  lut5 -n3 '(i2 and i1) or (not i2 and i0)'")
        sys.exit(1)
    expression = args[0]

    print("# expression = %s" % (expression))
    print("#in: i4 i3 i2 i1 i0 out weight")

    function = 0
    for i in range(1 << int(opts.inputs)):
        weight = 1 << i
        i0 = True if i & 1 else False
        i1 = True if i & 2 else False
        i2 = True if i & 4 else False
        i3 = True if i & 8 else False
        i4 = True if i & 16 else False
        result = eval(expression)
        print(
            "#%2d:  %d  %d  %d  %d  %d  %d" %
            (i, int(i4), int(i3), int(i2), int(i1), int(i0), int(result)), )
        if result:
            function += weight
            print("  0x%x" % (weight))
        else:
            print
    print("# setp lut5.N.function 0x%x" % (function))
Пример #23
0
def main():
    usage = "usage: %prog [options] expression"
    parser = OptionParser(usage=usage)
    parser.disable_interspersed_args()
    parser.add_options(options)

    (opts, args) = parser.parse_args()

    if not args:
        parser.print_help()
        print "examples:"
        print "  lut5 'i0 &  i1 &  i2 &  i3 &  i4'"
        print "  lut5 'i0 |  i1 |  i2 |  i3 |  i4'"
        print "  lut5 -n2 'i0 ^  i1'"
        print "# a two-line mux:"
        print "  lut5 -n3 '(i2 and i1) or (not i2 and i0)'"
        print "  lut5 -n3 '(i2 & i1) | (~i2 & i0)'"
        sys.exit(1)
    expression = args[0]

    print "# expression = %s" % (expression)
    print "#in: i4 i3 i2 i1 i0 out weight"

    function = 0
    for i in range(1 << int(opts.inputs)):
        weight = 1 << i
        i0 = True if i & 1 else False
        i1 = True if i & 2 else False
        i2 = True if i & 4 else False
        i3 = True if i & 8 else False
        i4 = True if i & 16 else False
        result = eval(expression)
        print "#%2d:  %d  %d  %d  %d  %d  %d" % (i,int(i4),int(i3),int(i2),int(i1),int(i0),int(result)),
        if result:
            function += weight
            print "  0x%x" % (weight)
        else:
            print
    print "# setp lut5.N.function 0x%x" % (function)
Пример #24
0
def get_opt_parser():
    # use module docstring for help output
    p = OptionParser(
        usage="%s [OPTIONS] [FILE ...]\n\n" % sys.argv[0] + __doc__,
        version="%prog " + nib.__version__)

    p.add_options([
        Option("-v", "--verbose", action="count",
               dest="verbose", default=0,
               help="Make more noise.  Could be specified multiple times"),

        Option("-H", "--header-fields",
               dest="header_fields", default='all',
               help="Header fields (comma separated) to be printed as well"
                    " (if present)"),

        Option("--ma", "--data-max-abs-diff",
               dest="data_max_abs_diff",
               type=float,
               default=0.0,
               help="Maximal absolute difference in data between files"
                    " to tolerate."),

        Option("--mr", "--data-max-rel-diff",
               dest="data_max_rel_diff",
               type=float,
               default=0.0,
               help="Maximal relative difference in data between files to"
                    " tolerate. If --data-max-abs-diff is also specified,"
                    " only the data points with absolute difference greater"
                    " than that value would be considered for relative"
                    " difference check."),
        Option("--dt", "--datatype",
               dest="dtype",
               default=np.float64,
               help="Enter a numpy datatype such as 'float32'.")
    ])

    return p
Пример #25
0
def get_opt_parser():
    # use module docstring for help output
    p = OptionParser(usage="%s [OPTIONS] [FILE ...]\n\n" % sys.argv[0] +
                     __doc__,
                     version="%prog " + nib.__version__)

    p.add_options([
        Option("-v",
               "--verbose",
               action="count",
               dest="verbose",
               default=0,
               help="Make more noise.  Could be specified multiple times"),
        Option(
            "-H",
            "--header-fields",
            dest="header_fields",
            default='all',
            help=
            "Header fields (comma separated) to be printed as well (if present)"
        ),
    ])

    return p
Пример #26
0
 def _parse_args(self):
     parser = OptionParser()
     parser.add_options(self.option_list)
     self.options, _ = parser.parse_args()
from django_nose import NoseTestSuiteRunner


def run_tests(*test_args, **kwargs):
    if 'south' in settings.INSTALLED_APPS:
        from south.management.commands import patch_for_test_db_setup
        patch_for_test_db_setup()

    if not test_args:
        test_args = ['entity_emailer']

    kwargs.setdefault('interactive', False)

    test_runner = NoseTestSuiteRunner(**kwargs)

    failures = test_runner.run_tests(test_args)
    sys.exit(failures)


if __name__ == '__main__':
    parser = OptionParser()
    parser.add_option('--verbosity',
                      dest='verbosity',
                      action='store',
                      default=1,
                      type=int)
    parser.add_options(NoseTestSuiteRunner.options)
    (options, args) = parser.parse_args()

    run_tests(*args, **options.__dict__)
Пример #28
0
              'is_active': False,
              'label': 'Default Inactive',
              'description': 'Controls the funkiness.',
            },
        },
    )

from django_nose import NoseTestSuiteRunner


def runtests(*test_args, **kwargs):
    if 'south' in settings.INSTALLED_APPS:
        from south.management.commands import patch_for_test_db_setup
        patch_for_test_db_setup()

    if not test_args:
        test_args = ['tests']

    test_runner = NoseTestSuiteRunner(**kwargs)

    failures = test_runner.run_tests(test_args)
    sys.exit(failures)

if __name__ == '__main__':
    parser = OptionParser()
    parser.add_option('--verbosity', dest='verbosity', action='store', default=1, type=int)
    parser.add_options(NoseTestSuiteRunner.options)
    (options, args) = parser.parse_args()

    runtests(*args, **options.__dict__)
Пример #29
0
    if 'south' in settings.INSTALLED_APPS:
        from south.management.commands import patch_for_test_db_setup
        patch_for_test_db_setup()

    if not test_args:
        test_args = ['celery_rpc']

    if sys.version_info >= (3, 10, 0):
        from django.test.runner import DiscoverRunner
        test_runner = DiscoverRunner(**kwargs)
    else:
        test_runner = NoseTestSuiteRunner(**kwargs)

    failures = test_runner.run_tests(test_args)
    sys.exit(failures)


if __name__ == '__main__':
    parser = OptionParser()
    parser.add_option('--verbosity',
                      dest='verbosity',
                      action='store',
                      default=1,
                      type=int)
    opts = getattr(NoseTestSuiteRunner, 'options', None)
    if opts:
        parser.add_options(opts)
    (options, args) = parser.parse_args()

    runtests(*args, **options.__dict__)
Пример #30
0
if __name__ == '__main__':
        usage =  '''
        Fit a series of measurements in a file 
        '''
        
        #options ....
        parser = OptionParser(usage=usage)
        
        parser.add_option("-a", '--amc-path',
                          dest="amc-path",
                          default='SPole_winter.amc',
                          help=" -a option: AM input template")
        
        parser.add_options('-p',
                           destination='pressure',
                           type=float,
                           default=680.0,
                           help='Ground level pressure (mbar), Default=680mB')
        
        parser.add_options('-t',
                           destination='temperature',
                           type=float,
                           default=243.0,
                           help='Ground level temperature (K), Default=243K = -30C')
        
        parser.add_options('-e',
                           type=float,
                           default=55.0,
                           help='Elevation of observation, Default=55')
        
        parser.add_option("-f", '--filename',
Пример #31
0
def main():
    """ creates a HAL component.
        parsees a glade XML file with gtk.builder or libglade
        calls gladevcp.makepins with the specified XML file
        to create pins and register callbacks.
        main window must be called "window1"
    """
    global gladevcp_debug
    (progdir, progname) = os.path.split(sys.argv[0])

    usage = "usage: %prog [options] myfile.ui"
    parser = OptionParser(usage=usage)
    parser.disable_interspersed_args()
    parser.add_options(options)

    (opts, args) = parser.parse_args()

    if not args:
        parser.print_help()
        sys.exit(1)

    gladevcp_debug = debug = opts.debug
    xmlname = args[0]

    #if there was no component name specified use the xml file name
    if opts.component is None:
        opts.component = os.path.splitext(os.path.basename(xmlname))[0]

    #try loading as a libglade project
    try:
        builder = gtk.glade.XML(xmlname)
        builder = GladeBuilder(builder)
    except:
        try:
            # try loading as a gtk.builder project
            print "**** GLADE VCP INFO:    Not a libglade project, trying to load as a GTK builder project"
            builder = gtk.Builder()
            builder.add_from_file(xmlname)
        except:
            print "**** GLADE VCP ERROR:    With xml file: %s" % xmlname
            sys.exit(0)

    window = builder.get_object("window1")

    window.set_title(opts.component)

    try:
        halcomp = hal.component(opts.component)
    except:
        print "*** GLADE VCP ERROR:    Asking for a HAL component using a name that already exists."
        sys.exit(0)

    panel = gladevcp.makepins.GladePanel(halcomp, xmlname, builder, None)

    # at this point, any glade HL widgets and their pins are set up.
    handlers = load_handlers(opts.usermod, halcomp, builder, opts.useropts)

    builder.connect_signals(handlers)

    if opts.parent:
        # block X errors since gdk error handling silently exits the
        # program without even the atexit handler given a chance
        gtk.gdk.error_trap_push()

        window = xembed.reparent(window, opts.parent)

        forward = os.environ.get('AXIS_FORWARD_EVENTS_TO', None)
        if forward:
            xembed.keyboard_forward(window, forward)

    window.connect("destroy", on_window_destroy)
    window.show()

    # for window resize and or position options
    if "+" in opts.geometry:
        try:
            j = opts.geometry.partition("+")
            pos = j[2].partition("+")
            window.move(int(pos[0]), int(pos[2]))
        except:
            print "**** GLADE VCP ERROR:    With window position data"
            parser.print_usage()
            sys.exit(1)
    if "x" in opts.geometry:
        try:
            if "+" in opts.geometry:
                j = opts.geometry.partition("+")
                t = j[0].partition("x")
            else:
                t = window_geometry.partition("x")
            window.resize(int(t[0]), int(t[2]))
        except:
            print "**** GLADE VCP ERROR:    With window resize data"
            parser.print_usage()
            sys.exit(1)

    if opts.gtk_workaround:
        # work around https://bugs.launchpad.net/ubuntu/+source/pygtk/+bug/507739
        # this makes widget and widget_class matches in gtkrc and theme files actually work
        dbg("activating GTK bug workaround for gtkrc files")
        for o in builder.get_objects():
            if isinstance(o, gtk.Widget):
                # retrieving the name works only for GtkBuilder files, not for
                # libglade files, so be cautious about it
                name = gtk.Buildable.get_name(o)
                if name: o.set_name(name)

    if opts.gtk_rc:
        dbg("**** GLADE VCP INFO: %s reading gtkrc file '%s'" %
            (opts.component, opts.gtk_rc))
        gtk.rc_add_default_file(opts.gtk_rc)
        gtk.rc_parse(opts.gtk_rc)

    if opts.theme:
        dbg("**** GLADE VCP INFO:    Switching %s to '%s' theme" %
            (opts.component, opts.theme))
        settings = gtk.settings_get_default()
        settings.set_string_property("gtk-theme-name", opts.theme, "")
    # This needs to be done after geometry moves so on dual screens the window maxumizes to the actual used screen size.
    if opts.maximum:
        window.window.maximize()

    if opts.halfile:
        cmd = ["halcmd", "-f", opts.halfile]
        res = subprocess.call(cmd, stdout=sys.stdout, stderr=sys.stderr)
        if res:
            print >> sys.stderr, "'%s' exited with %d" % (' '.join(cmd), res)
            sys.exit(res)

    # User components are set up so report that we are ready
    halcomp.ready()

    if handlers.has_key(signal_func):
        dbg("Register callback '%s' for SIGINT and SIGTERM" % (signal_func))
        signal.signal(signal.SIGTERM, handlers[signal_func])
        signal.signal(signal.SIGINT, handlers[signal_func])

    try:
        gtk.main()
    except KeyboardInterrupt:
        sys.exit(0)
    finally:
        halcomp.exit()

    if opts.parent:
        gtk.gdk.flush()
        error = gtk.gdk.error_trap_pop()
        if error:
            print "**** GLADE VCP ERROR:    X Protocol Error: %s" % str(error)
Пример #32
0
    )

try:
    from django.test.runner import DiscoverRunner as Runner
except ImportError:
    from django.test.simple import DjangoTestSuiteRunner as Runner


def runtests(*test_args, **kwargs):
    if 'south' in settings.INSTALLED_APPS:
        from south.management.commands import patch_for_test_db_setup
        patch_for_test_db_setup()

    if not test_args:
        test_args = ['uuidfield']

    kwargs.setdefault('interactive', False)

    test_runner = Runner(**kwargs)

    failures = test_runner.run_tests(test_args)
    sys.exit(failures)

if __name__ == '__main__':
    parser = OptionParser()
    parser.add_option('--verbosity', dest='verbosity', action='store', default=1, type=int)
    parser.add_options(Runner.options)
    (options, args) = parser.parse_args()

    runtests(*args, **options.__dict__)
Пример #33
0
def make_parser():
    description = """
    Fbuild is a new kind of build system that is designed around caching
    instead of tree evaluation.
    """

    epilog = '\nTargets:\n{}\n'.format(fbuild.target.help_string())

    parser = OptionParser(
        version=fbuild.__version__,
        usage='%prog [options] target1 [target2 target3 ...]',
        description=description,
        epilog=epilog)

    parser.add_options([
        make_option('-v', '--verbose',
            action='count',
            default=0,
            help='print out extra debugging info'),
        make_option('--show',
            action='count',
            default=1,
            help='print out extra debugging info'),
        make_option('-j', '--jobs',
            dest='threadcount',
            metavar='N',
            type='int',
            default=1,
            help='Allow N jobs at once'),
        make_option('--nocolor',
            action='store_true',
            default=False,
            help='Do not use colors'),
        make_option('--show-threads',
            action='store_true',
            default=False,
            help='Show which thread is running which command'),
        make_option('--configure',
            dest='force_configuration',
            action='store_true',
            default=False,
            help='force reconfiguration'),
        make_option('--buildroot',
            action='store',
            default='build',
            help='where to store the build files (default build)'),
        make_option('--state-file',
            action='store',
            default='fbuild-state.db',
            help='the name of the state file ' \
                 '(default buildroot/fbuild-state.db)'),
        make_option('--log-file',
            action='store',
            default='fbuild.log',
            help='the name of the log file (default fbuild.log)'),
        make_option('--dump-state',
            action='store_true',
            default=False,
            help='print the state database'),
        make_option('--clean',
            dest='clean_buildroot',
            action='store_true',
            default=False,
            help='clean the build directory'),
        make_option('--delete-function',
            action='store',
            help='delete cached data for the specified function'),
        make_option('--delete-file',
            action='store',
            help='delete cached data for the specified file'),
        make_option('--do-not-save-database',
            action='store_true',
            default=False,
            help='do not save the results of the database for testing.'),
        make_option('--explain-database',
            action='store_true',
            default=False,
            help='explain why a function was not cached.'),
        make_option('--database-engine',
            action='store',
            choices=('pickle', 'sqlite', 'cache'),
            default='pickle',
            help='which database engine to use: (pickle, sqlite). pickle is ' \
                'the default'),
    ])

    return parser
Пример #34
0
class Builder(object):
    """docstring for Builder"""
    __usage__ = "%prog <namespace>.<blueprint> [options]"
    
    def __init__(self):
        super(Builder, self).__init__()
        self.build_parser()
        self.config = BuilderConfig(CONFIG_DIR)
        self.plugins = self.config.plugins
        self.loaded_plugins = []
        self.aliases = copy(self.config.aliases)
        self.blueprints = self.get_blueprints()
        self.logger = logger
        self.plugin_data = {}
    # end def __init__
    
    @property
    def help(self):
        return self.parser.print_help()
    # end def
    
    def build_parser(self):
        self.parser = OptionParser(prog='builder', usage=self.__usage__)
        self.parser.add_option('--logging-level', help='Set logging level. (Default: INFO)', action="store", default='INFO')
        self.parser.add_option('--list-namespaces', help='List the available plugins.', action="store_true", default=False)
        self.parser.add_option('--list-blueprints', help='List the available blueprints for a plugin.', 
                                action="store_true", default=False)
    # end def build_parser
    
    def parse_blueprint_name(self, fullname):
        parts = fullname.split('.', 1)
        namespace = parts[0]
        blueprint_name = "default" if len(parts) == 1 else parts[1]
        return namespace, blueprint_name
    # end def parse_plugin_blueprint
    
    def main(self, input_args=sys.argv):
        cmd_args = copy(input_args)
        script = cmd_args.pop(0)
        if not cmd_args:
            print self.help
            sys.exit(2)
        elif '--list-namespaces' in cmd_args:
            print "Installed plugins:"
            print ", ".join(sorted(self.blueprints.keys()))
            sys.exit(0)
        # end if

        blueprint_fullname = cmd_args.pop(0)    
        if blueprint_fullname.startswith('-'):
            options, args = self.parser.parse_args(input_args)
            # if parsed and -h/--help is not there print help anyways 
            # since the args are incorrect.
            print "Blueprint must the be the first argument."
            print self.help
            sys.exit(2) 
            # end if
        # end if
        
        aliased = self.aliases.get(blueprint_fullname)
        if aliased:
            alias_args = aliased.split()
            blueprint_fullname = alias_args.pop(0)
            # Only one level of recursion for aliases at this time.
            nested_alias = self.aliases.get(blueprint_fullname)
            if nested_alias:
                blueprint_fullname = nested_alias
            # end if
            # insert that alias's args before the command line args
            new_cmd_args = alias_args
            new_cmd_args.extend(cmd_args)
            cmd_args = new_cmd_args
        # end if
        
        namespace, blueprint_name = self.parse_blueprint_name(blueprint_fullname)
        if namespace not in self.blueprints:
            print "Error finding blueprint '%s'.\n" % blueprint_fullname
            print "Installed plugins:"
            print ", ".join(sorted(self.plugins))
            print "Namespaces from plugins:"
            print ", ".join(sorted(self.blueprints.keys()))
            sys.exit(1)
        # end if 

        if '--list-blueprints' in cmd_args:
            print "Installed blueprints for '%s':" % (namespace)
            print ", ".join(self.blueprints[namespace].keys())
            sys.exit(0)
        # end if
        
        blueprint_cls = self.blueprints[namespace].get(blueprint_name)
        if not blueprint_cls:
            print "No blueprint '%s'" % (blueprint_name)
            print "Blueprints for '%s':" % (namespace)
            print "\t", ", ".join(self.blueprints[namespace].keys())
            sys.exit(1)
        # end if
        
        self.parser.add_options(blueprint_cls.options)
        self.parser.prog = '%s %s' % (self.parser.prog, blueprint_fullname)
        options, args = self.parser.parse_args(cmd_args)
        # set logging level
        self.logger.setLevel(getattr(logging, options.logging_level.upper()))
        exit_code = 0
        if not self.run_blueprint(
            blueprint_cls, 
            self.build_context(options, self.config.get_blueprint_config(blueprint_fullname)), 
            args):
            exit_code = 1
        # end if
        sys.exit(exit_code)
    # end def main
    
    def build_context(self, option_values, blueprint_config):
        context = {}
        context.update(blueprint_config)
        for option, value in option_values.__dict__.iteritems():
            if value != None:
                context[option] = value
            # end if
        # end for
        if 'list_blueprints' in context:
            del context['list_blueprints']
        # end if
        if 'list_namespaces'in context:
            del context['list_namespaces']
        # end if
        if 'logging_level'in context:
            del context['logging_level']
        # end if
        return context
    # end def build_context
    
    def run_blueprint(self, blueprint_cls, context, args):
        blueprint = blueprint_cls()
        valid = blueprint.validate(context, args)
        success = False
        if valid:
            try:
                blueprint.run(context, args)
                success = True
            except Exception, run_ex:
                print "Error running '%s' blueprint:\n" % (blueprint)
                print run_ex
                try:
                    blueprint.rollback(context, args)
                except Exception, roll_ex:
                    print "Error rolling back '%s' blueprint:\n" % (blueprint)
                    print roll_ex
Пример #35
0
def main():
    parser = OptionParser(usage="%s WHEEL_FILENAME\n\n" % sys.argv[0] +
                          __doc__,
                          version="%prog " + __version__)
    parser.add_options([
        Option("-L",
               "--lib-sdir",
               action="store",
               type='string',
               default='.dylibs',
               help="Subdirectory in packages to store copied libraries"),
        Option("-w",
               "--wheel-dir",
               action="store",
               type='string',
               help="Directory to store delocated wheels (default is to "
               "overwrite input)"),
        Option("-v",
               "--verbose",
               action="store_true",
               help="Show more verbose report of progress and failure"),
        Option("-k",
               "--check-archs",
               action="store_true",
               help="Check architectures of depended libraries"),
        Option("-d",
               "--dylibs-only",
               action="store_true",
               help="Only analyze files with known dynamic library "
               "extensions"),
        Option("--require-archs",
               action="store",
               type='string',
               help="Architectures that all wheel libraries should "
               "have (from 'intel', 'i386', 'x86_64', 'i386,x86_64')"),
        Option("-i",
               "--insert_file",
               action="store",
               type='string',
               help="Force insert file")
    ])

    (opts, wheels) = parser.parse_args()
    if len(wheels) < 1:
        parser.print_help()
        sys.exit(1)
    multi = len(wheels) > 1
    if opts.wheel_dir:
        wheel_dir = expanduser(opts.wheel_dir)
        if not exists(wheel_dir):
            os.makedirs(wheel_dir)
    else:
        wheel_dir = None
    if opts.require_archs is None:
        require_archs = [] if opts.check_archs else None
    elif ',' in opts.require_archs:
        require_archs = [s.strip() for s in opts.require_archs.split(',')]
    else:
        require_archs = opts.require_archs
    lib_filt_func = 'dylibs-only' if opts.dylibs_only else None
    for wheel in wheels:
        if multi or opts.verbose:
            print('Fixing: ' + wheel)
        if wheel_dir:
            out_wheel = pjoin(wheel_dir, basename(wheel))
        else:
            out_wheel = wheel
        copied = delocate_wheel(wheel,
                                out_wheel,
                                lib_filt_func=lib_filt_func,
                                lib_sdir=opts.lib_sdir,
                                require_archs=require_archs,
                                check_verbose=opts.verbose,
                                insert_file=opts.insert_file)
        if opts.verbose and len(copied):
            print("Copied to package {0} directory:".format(opts.lib_sdir))
            copy_lines = ['  ' + name for name in sorted(copied)]
            print('\n'.join(copy_lines))
def main(argv=sys.argv):
    """ Merge a configuration/layer to the project. """
    parser = OptionParser(version="%%prog %s" % VERSION)
    
    parser.add_options(cone_common.COMMON_OPTIONS)
    
    parser.add_option("-c", "--configuration",\
                        dest="configuration",\
                        help="defines the name of the target configuration for the action",\
                        metavar="CONFIG")

    parser.add_option("-p", "--project",\
                       dest="project",\
                       help="defines the location of current project. Default is the current working directory.",\
                       default=".",\
                       metavar="STORAGE")
    
    group = OptionGroup(parser, 'Merge options',
                        'The merge functionality is meant to merge configurations/layers '
                        'from a remote project (defined with -r) to the current project (defined with -p). '
                        'Default value for the current project is the currently working directory. '
                        'A project can be either a folder or a cpf/zip file. There are two ways to '
                        'use merge: merge configuration roots (multiple layers), or specific layers. '
                        'See the ConE documentation for details and examples.')
    
    group.add_option("-r", "--remote",\
                   dest="remote",\
                   help="defines the location of remote storage",\
                   metavar="STORAGE")
    
    group.add_option("-s", "--sourceconfiguration",\
                        dest="sourceconfiguration",\
                        help="defines the name of the remote configuration inside the remote storage for the merge action. "\
                             "Default is the active root of the remote project.",\
                        metavar="CONFIG")
    
    group.add_option("--sourcelayer",
                     help="Defines a specific layer to use as the layer to merge "\
                          "from the remote project. Must be the layer root (ConfML file)."\
                          "For example: --sourcelayer assets/somelayer/root.confml",
                     metavar="LAYER_ROOT",
                     default=None)
    
    group.add_option("--targetlayer",
                     help="Defines a specific layer (root) to use as the layer to merge "\
                          "into the target project. Must be the layer root (ConfML file)."\
                          "For example: --targetlayer assets/somelayer/root.confml",
                     metavar="LAYER_ROOT",
                     default=None)

    group.add_option("--rename",\
                        action="store_true", 
                        dest="rename",\
                        help="defines that the merged layers need to be renamed",
                        default=False)

    group.add_option("--all",\
                        action="store_true", 
                        dest="all",\
                        help="Defines that the entire configuration (all layers) needs to be merged. "\
                             "This has no effect when merging layers directly using --sourcelayer and --targetlayer.",
                        default=False)

    group.add_option("-l", "--layer",\
                   dest="layers",\
                   type="int",
                   action="append",
                   help="Define the layers of the source configuration that are included to merge action. "\
                        "The layer operation can be used several times in a single command. "\
                        "Note that this can only be used when merging configuration roots, not "\
                        "specific layers using --sourcelayer and --targetlayer. "\
                        "Example -l -1 --layer=-2, which would append a layers -1 and -2 to the layers => layers = -1,-2",
                   metavar="LAYERS",\
                   default=None)
    
    group.add_option("--merge-policy",
                     help="Specifies the merge policy to use when merging layers. "\
                          "Possible values:                                                         "\
                          "replace-add - Add/replace files from source layer, but leave other files in the target as they are. "\
                          "                                                         "\
                          "overwrite-layer - Overwrite the entire layer (remove all previous content).",
                     default=MergePolicy.REPLACE_ADD)
    
    parser.add_option_group(group)
    (options, _) = parser.parse_args(argv)
    
    cone_common.handle_common_options(options)
    
    # Check the passed options
    if not MergePolicy.is_valid(options.merge_policy):
        parser.error("Invalid merge policy: %s\nMust be one of %s" % (options.merge_policy, '\n'.join(MergePolicy.ALL)))
    if not options.remote: parser.error("Remote project must be given")
    if options.layers and (options.sourcelayer or options.targetlayer):
        parser.error("Specifying layer indices using --layer is not supported when using --sourcelayer or --targetlayer!")
    if options.sourcelayer and not options.targetlayer:
        parser.error("Merging a layer into a configuration is not supported at the moment!")
    if options.sourcelayer and not options.sourcelayer.lower().endswith('.confml'):
        parser.error("Source layer root should be a .confml file")
    if options.targetlayer and not options.targetlayer.lower().endswith('.confml'):
        parser.error("Target layer root should be a .confml file")
    if not options.sourcelayer and options.targetlayer:
        parser.error("Cannot merge a configuration into a layer!")
    
    # If layers for configuration root merging are not specifically given,
    # the default is the last layer
    if options.layers is None:
        options.layers = [-1]
    
    target_project = api.Project(api.Storage.open(options.project,"a", username=options.username, password=options.password))
    source_project = api.Project(api.Storage.open(options.remote,"r", username=options.username, password=options.password))
    
    print "Target project: %s" % options.project
    print "Source project: %s" % options.remote
    
    target_config = None
    try:
        if options.sourcelayer and options.targetlayer:
            print "Target layer:   %s" % options.targetlayer
            print "Source layer:   %s" % options.sourcelayer
            
            try:
                source_config = source_project.get_configuration(options.sourcelayer)
            except exceptions.NotFound:
                raise MergeFailedException("Layer root '%s' not found in source project" % options.sourcelayer)
            
            try:
                target_config = target_project.get_configuration(options.targetlayer)
            except exceptions.NotFound:
                logger.info('Creating new layer %s' % (options.targetlayer))
                target_config  = target_project.create_configuration(options.targetlayer)
            
            print "Merging layers..."
            merge_configuration_layer(source_config, target_config, options.merge_policy)
        else:
            # Merging a configuration root into a configuration root
            
            if options.all: layer_indices = None
            else:           layer_indices = utils.distinct_array(options.layers)
            
            def find_layers(source_config, target_config):
                return find_layers_to_merge(
                    layer_indices   = layer_indices,
                    rename          = options.rename,
                    sourceconfig    = source_config,
                    targetconfig    = target_config)
            
            merge_config_root_to_config_root(
                source_project      = source_project,
                target_project      = target_project,
                source_config       = options.sourceconfiguration,
                target_config       = options.configuration,
                layer_finder_func   = find_layers,
                merge_policy        = options.merge_policy)
    except MergeFailedException, e:
        print "Could not merge: %s" % e
        sys.exit(2)
Пример #37
0
def getOptions():
    arguments = OptionParser()
    arguments.add_options(["--username", "--password", "--firstyear"])
    return arguments.parse_args()[0]
Пример #38
0
    
    n_ch = len(Channels_dat)                
    plt.pcolor(np.ma.array(np.abs(Con_cc),mask=np.eye(Con_cc.shape[0]))
                           ,cmap=plt.cm.cool)
    #plt.colorbar()
    
    
    if ProbeFileName is not None and len(edges(ChannelGraph))>0:
        ptsx1,ptsy1 = np.array(edges(ChannelGraph)).T
        plt.plot(ptsx1+.5,ptsy1+.5,'kx',ms=10,mew=3)
        
        
    ax = plt.gca()
    ax.set_xticks(np.arange(n_ch)+.5)
    ax.set_yticks(np.arange(n_ch)+.5)
    ax.set_xticklabels(ChNames,rotation='vertical')
    ax.set_yticklabels(ChNames)
    
    basename = basename_noext(ProbeFileName) if ProbeFileName else basename_noext(DatFileName)
    outpath = os.path.join(output_dir or ProbeFileName and os.path.dirname(ProbeFileName) or DatDir,"%s_crosstalk.png"%basename)
    print("saving figure in %s"%outpath)
    plt.savefig(outpath)   
    
if __name__ == '__main__':
    usage = """%prog your_dat_file.dat [options]
    %prog -h displays help"""
    parser = OptionParser(usage)
    parser.add_options([caton.myopts.probe,caton.myopts.output])
    (opts,args) = parser.parse_args()
    check_crosstalk(args[0],opts.probe,opts.output)
Пример #39
0
#!/usr/bin/env python
import sys,os,shutil
from optparse import OptionParser
from caton.core import classify_from_raw_data
import caton.myopts

usage = """
This is the main script that you use to spike-sort your data.
Just make the probe file and you're good to go (see documentation).
If you don't specify a probe file or probe directory, I will use every probe file in directory of dat file.
I will prompt you for sample rate and number of channels if no xml file is found.

%prog your_dat_file.dat [options]
%prog -h displays help"""
parser = OptionParser(usage)
parser.add_options([caton.myopts.probe,caton.myopts.max_spikes,caton.myopts.output,caton.myopts.fast,caton.myopts.fast2,caton.myopts.params])
parser.add_option("--probe-dir",action="store",dest="probe_dir",help="Run the clustering script once for every probe file in the specified directory. Defaults to the directory of the data file. If you want to select a single probe file, use the -p (or --probe=) option.")

if __name__ == '__main__':
    (opts,args) = parser.parse_args()                
        
    if len(args) == 0:
        parser.error("Must specify a dat file")
                        
    DatFileName = args[0]
    if not os.path.exists(DatFileName):
        parser.error("raw data file not found: %s"%DatFileName)        

    if opts.probe is not None:
        probe_files = [opts.probe]
    else:
Пример #40
0
def getOptions():  
   arguments = OptionParser()  
   arguments.add_options(["--email", "--password"])  
   return arguments.parse_args()[0]  
Пример #41
0
def main():
    """ creates a HAL component.
        parsees a glade XML file with Gtk.builder or libglade
        calls gladevcp.makepins with the specified XML file
        to create pins and register callbacks.
        main window must be called "window1"
    """
    global gladevcp_debug
    (progdir, progname) = os.path.split(sys.argv[0])

    usage = "usage: %prog [options] myfile.ui"
    parser = OptionParser(usage=usage)
    parser.disable_interspersed_args()
    parser.add_options(options)

    (opts, args) = parser.parse_args()
    if not args:
        parser.print_help()
        sys.exit(1)

    gladevcp_debug = debug = opts.debug
    xmlname = args[0]

    #if there was no component name specified use the xml file name
    if opts.component is None:
        opts.component = os.path.splitext(os.path.basename(xmlname))[0]

    #try loading as a libglade project
    try:
        builder = Gtk.Builder()
        builder.add_from_file(xmlname)
    except:
        try:
            # try loading as a Gtk.builder project
            dbg("**** GLADE VCP INFO:    Not a builder project, trying to load as a lib glade project")
            builder = Gtk.glade.XML(xmlname)
            builder = GladeBuilder(builder)

        except Exception as e:
            print("**** GLADE VCP ERROR:    With xml file: %s : %s" % (xmlname,e), file=sys.stderr)
            sys.exit(0)

    window = builder.get_object("window1")

    window.set_title(opts.component)

    try:
        halcomp = hal.component(opts.component)
    except:
        print("*** GLADE VCP ERROR:    Asking for a HAL component using a name that already exists.", file=sys.stderr)
        sys.exit(0)

    panel = gladevcp.makepins.GladePanel( halcomp, xmlname, builder, None)

    # at this point, any glade HL widgets and their pins are set up.
    handlers, mod, obj = load_handlers(opts.usermod,halcomp,builder,opts.useropts)

    # so widgets can call handler functions - give them refeence to the handler object
    panel.set_handler(obj)

    builder.connect_signals(handlers)

    # This option puts the gladevcp panel into a plug and pushed the plug's
    # X window id number to standard output - so it can be reparented exterally
    # it also forwards events to qtvcp
    if opts.push_XID:
        if not opts.debug:
            # supress warnings when x window closes
            warnings.filterwarnings("ignore")
        # block X errors since Gdk error handling silently exits the
        # program without even the atexit handler given a chance
        Gdk.error_trap_push()

        forward = os.environ.get('QTVCP_FORWARD_EVENTS_TO', None)
        if forward:
            xembed.keyboard_forward(window, forward)

    # This option reparents gladevcp in a given X window id.
    # it also forwards keyboard events from gladevcp to AXIS
    if opts.parent:
        if not opts.debug:
            # supress warnings when x window closes
            warnings.filterwarnings("ignore")
        # block X errors since Gdk error handling silently exits the
        # program without even the atexit handler given a chance
        Gdk.error_trap_push()

        window = xembed.reparent(window, opts.parent)

        forward = os.environ.get('AXIS_FORWARD_EVENTS_TO', None)
        if forward:
            xembed.keyboard_forward(window, forward)

    window.connect("destroy", on_window_destroy)
    window.show()

    # for window resize and or position options
    if "+" in opts.geometry:
        try:
            j =  opts.geometry.partition("+")
            pos = j[2].partition("+")
            window.move( int(pos[0]), int(pos[2]) )
        except:
            print("**** GLADE VCP ERROR:    With window position data", file=sys.stderr)
            parser.print_usage()
            sys.exit(1)
    if "x" in opts.geometry:
        try:
            if "+" in opts.geometry:
                j =  opts.geometry.partition("+")
                t = j[0].partition("x")
            else:
                t = window_geometry.partition("x")
            window.resize( int(t[0]), int(t[2]) )
        except:
            print("**** GLADE VCP ERROR:    With window resize data", file=sys.stderr)
            parser.print_usage()
            sys.exit(1)

    if opts.gtk_rc:
        dbg( "**** GLADE VCP INFO: %s reading gtkrc file '%s'" %(opts.component,opts.gtk_rc))
        Gtk.rc_add_default_file(opts.gtk_rc)
        Gtk.rc_parse(opts.gtk_rc)

    if opts.theme:
        dbg("**** GLADE VCP INFO:    Switching %s to '%s' theme" %(opts.component,opts.theme))
        settings = Gtk.Settings.get_default()
        settings.set_string_property("gtk-theme-name", opts.theme, "")

    # This needs to be done after geometry moves so on dual screens the window maxumizes to the actual used screen size.
    if opts.maximum:
        window.window.maximize()
    if opts.always_above_flag:
        window.set_keep_above(True)
    if opts.halfile:
        if opts.halfile[-4:] == ".tcl":
            cmd = ["haltcl", opts.halfile]
        else:
            cmd = ["halcmd", "-f", opts.halfile]
        res = subprocess.call(cmd, stdout=sys.stdout, stderr=sys.stderr)
        if res:
            print("'%s' exited with %d" %(' '.join(cmd), res), file=sys.stderr)
            sys.exit(res)

    # User components are set up so report that we are ready
    halcomp.ready()
    GSTAT.forced_update()

    # push the XWindow id number to standard out
    if opts.push_XID or opts.parent:
        w_id = window.get_property('window').get_xid()
        print(w_id, file=sys.stdout)
        sys.stdout.flush()

    if signal_func in handlers:
        dbg("Register callback '%s' for SIGINT and SIGTERM" %(signal_func))
        signal.signal(signal.SIGTERM, handlers[signal_func])
        signal.signal(signal.SIGINT,  handlers[signal_func])

    try:
        Gtk.main()
    except KeyboardInterrupt:
        sys.exit(0)
    finally:
        halcomp.exit()

    if opts.parent or opts.push_XID:
        Gdk.flush()
        error = Gdk.error_trap_pop()
        if error and opts.debug:
            print("**** GLADE VCP ERROR:    X Protocol Error: %s" % str(error), file=sys.stderr)
Пример #42
0
def get_opt_parser():
	# use module docstring for help output
	p = OptionParser(
				usage="%s [OPTIONS] <LOG> <REGEX> [IGNOREREGEX]\n" % sys.argv[0] + __doc__
				+ """
LOG:
    string                  a string representing a log line
    filename                path to a log file (/var/log/auth.log)
    "systemd-journal"       search systemd journal (systemd-python required)

REGEX:
    string                  a string representing a 'failregex'
    filename                path to a filter file (filter.d/sshd.conf)

IGNOREREGEX:
    string                  a string representing an 'ignoreregex'
    filename                path to a filter file (filter.d/sshd.conf)

Copyright (c) 2004-2008 Cyril Jaquier, 2008- Fail2Ban Contributors
Copyright of modifications held by their respective authors.
Licensed under the GNU General Public License v2 (GPL).

Written by Cyril Jaquier <*****@*****.**>.
Many contributions by Yaroslav O. Halchenko and Steven Hiscocks.

Report bugs to https://github.com/fail2ban/fail2ban/issues
""",
				version="%prog " + version)

	p.add_options([
		Option("-d", "--datepattern",
			   help="set custom pattern used to match date/times"),
		Option("-e", "--encoding",
			   help="File encoding. Default: system locale"),
		Option("-r", "--raw", action='store_true',
			   help="Raw hosts, don't resolve dns"),
		Option("-L", "--maxlines", type=int, default=0,
			   help="maxlines for multi-line regex"),
		Option("-m", "--journalmatch",
			   help="journalctl style matches overriding filter file. "
			   "\"systemd-journal\" only"),
		Option('-l', "--log-level", type="choice",
			   dest="log_level",
			   choices=('heavydebug', 'debug', 'info', 'notice', 'warning', 'error', 'critical'),
			   default=None,
			   help="Log level for the Fail2Ban logger to use"),
		Option("-v", "--verbose", action='store_true',
			   help="Be verbose in output"),
		Option("-D", "--debuggex", action='store_true',
			   help="Produce debuggex.com urls for debugging there"),
		Option("--print-no-missed", action='store_true',
			   help="Do not print any missed lines"),
		Option("--print-no-ignored", action='store_true',
			   help="Do not print any ignored lines"),
		Option("--print-all-matched", action='store_true',
			   help="Print all matched lines"),
		Option("--print-all-missed", action='store_true',
			   help="Print all missed lines, no matter how many"),
		Option("--print-all-ignored", action='store_true',
			   help="Print all ignored lines, no matter how many"),
		Option("-t", "--log-traceback", action='store_true',
			   help="Enrich log-messages with compressed tracebacks"),
		Option("--full-traceback", action='store_true',
			   help="Either to make the tracebacks full, not compressed (as by default)"),
		])

	return p
Пример #43
0
 def add_options(self, option_list):
   self.base_options = (self.base_options + option_list)
   OptionParser.add_options(self, option_list)
Пример #44
0
    def __init__(self):
        
        usage = "usage: %prog [options] /dev/video_device_name"
        parser = OptionParser(usage=usage)
        parser.disable_interspersed_args()
        parser.add_options(options)
        
        (opts, args) = parser.parse_args()

        if not args:
            parser.print_help()
            sys.exit(1)
        
        self.window = Gtk.Window()
        self.window.set_default_size(1024, 600)
        
        xid = None
        if opts.parent:
            xid = int(opts.parent)
            plug = Gtk.Plug.new(xid)
            for c in self.window.get_children():
                self.window.remove(c)
                plug.add(c)
            self.window = plug

        self.drawingarea = Gtk.DrawingArea()
        self.window.add(self.drawingarea)
        self.window.connect('destroy', self.quit)

        # Create GStreamer pipeline
        self.pipeline = Gst.Pipeline()

        # Create bus to get events from GStreamer pipeline
        self.bus = self.pipeline.get_bus()
        self.bus.add_signal_watch()
        self.bus.connect('message::error', self.on_error)

        # This is needed to make the video output in our DrawingArea:
        self.bus.enable_sync_message_emission()
        self.bus.connect('sync-message::element', self.on_sync_message)

        # Create GStreamer elements

        # testing: self.src = Gst.ElementFactory.make('videotestsrc', None)
        self.src = Gst.ElementFactory.make('v4l2src', None)
        self.src.set_property("device", args[0])
        
        # cameracaps = gst.caps_from_string("video/x-raw, format=YV12 width=1280, height=720, framerate=30/1")
        cameracaps = Gst.Caps.from_string("image/jpeg, width=1280, height=720, framerate=30/1")
        self.camerafilter = Gst.ElementFactory.make("capsfilter", "filter") 
        self.camerafilter.set_property("caps", cameracaps)
        
        self.jpegdec = Gst.ElementFactory.make('jpegdec', 'jpegdec')

        # self.sink = Gst.ElementFactory.make('autovideosink', None)
        self.sink = Gst.ElementFactory.make('xvimagesink', None)
        self.sink.set_property("sync", "false")

        # Add elements to the pipeline
        self.pipeline.add(self.src)
        self.pipeline.add(self.camerafilter)
        self.pipeline.add(self.jpegdec)
        self.pipeline.add(self.sink)

        self.src.link(self.camerafilter)
        self.camerafilter.link(self.jpegdec)
        self.jpegdec.link(self.sink)
Пример #45
0
 def _parse_args(self):
     parser = OptionParser()
     parser.add_options(self.option_list)
     self.options, _ = parser.parse_args()
Пример #46
0
def main():
    """ creates a HAL component.
        parsees a glade XML file with gtk.builder or libglade
        calls gladevcp.makepins with the specified XML file
        to create pins and register callbacks.
        main window must be called "window1"
    """
    global gladevcp_debug
    (progdir, progname) = os.path.split(sys.argv[0])

    usage = "usage: %prog [options] myfile.ui"
    parser = OptionParser(usage=usage)
    parser.disable_interspersed_args()
    parser.add_options(options)

    (opts, args) = parser.parse_args()

    if not args:
        parser.print_help()
        sys.exit(1)

    BASE = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), ".."))
    libdir = os.path.join(BASE, "lib", "python")
    sys.path.append(libdir)
    arhmidir = os.path.join(BASE, "lib", "python", "arhmi")
    sys.path.append(arhmidir)

    gladevcp_debug = debug = opts.debug
    xmlname = args[0]

    #if there was no component name specified use the xml file name
    if opts.component is None:
        opts.component = os.path.splitext(os.path.basename(xmlname))[0]

    builder = gtk.Builder()
    # try loading as a gtk.builder project
    try:
        builder.add_from_file(xmlname)
    except:
        #         #try loading as a libglade project
        #         try:
        #             dbg("**** GLADE VCP INFO:    Not a GtkBuilder project, trying to load as a GTK builder project")
        #             builder = gtk.glade.XML(xmlname)
        #             builder = GladeBuilder(builder)
        try:
            # for arhmi applications
            LOCALEDIR = os.path.join(BASE, "share", "locale")
            o = "plasma"
            gettext.install(o, localedir=LOCALEDIR, unicode=True)
            gtk.glade.bindtextdomain(o, LOCALEDIR)
            gtk.glade.textdomain(o)

            base = os.path.abspath(
                os.path.join(os.path.dirname(sys.argv[0]), ".."))
            sharedir = os.path.join(base, "share", "linuxcnc")
            gladefile = os.path.join(sharedir, xmlname)
            builder.add_from_file(gladefile)
        except Exception, e:
            print >> sys.stderr, "**** GLADE VCP ERROR:    With xml file: %s : %s" % (
                xmlname, e)
            sys.exit(0)
Пример #47
0
def main():
    """ Create report of existing report data. """
    parser = OptionParser(version="%%prog %s" % VERSION)
    
    parser.add_options(cone_common.COMMON_OPTIONS)
    
    group = OptionGroup(parser, 'Report options',
                        'The report function generates a report using previously generated '\
                        'intermediary report data as input.')
    
    group.add_option("-i", "--input-data",\
                        action="append",\
                        help="Defines an input file for report generation. "\
                             "If specified more than once, the data of all specified "\
                             "report data files is merged.",
                        metavar="FILE",
                        default=[])
    
    group.add_option("-d", "--input-data-dir",\
                        help="Defines a directory containing the data files to use for "\
                             "generating the report. This is an alternative to specifying "\
                             "a number of --input-data files. The order of the data files "\
                             "is determined by the generation time stamps found in the data "\
                             "files.",
                        metavar="DIR",
                        default=None)
    
    group.add_option("-r", "--report",\
                   dest="report",\
                   action="store",
                   type="string",
                   help="Specifies the report file to create."\
                        "Example -r report.html.",
                   metavar="FILE",\
                   default="report.html")
    
    group.add_option("--report-option",\
                   action="append",
                   help="Specifies the report verbose options, that defines "\
                        "what data is included to the report. The option can be "\
                        "used multiple times."\
                        "choises=[default|all]"\
                        "Example --report-option=all",
                   metavar="OPTION",\
                   default=[])

    group.add_option("-t", "--template",\
                   dest="template",\
                   action="store",
                   type="string",
                   help="Template used in report generation."\
                        "Example -t report_template.html.",
                   metavar="FILE",\
                   default=None)
    
    parser.add_option_group(group)
    (options, args) = parser.parse_args()
    
    cone_common.handle_common_options(options)
    
    if len(options.input_data) == 0 and not options.input_data_dir:
        parser.error("Input data must be specified with either --input-data or --input-data-dir")
    if len(options.input_data) > 0 and options.input_data_dir:
        parser.error("Both --input-data and --input-data-dir specified, use one or the other.")
    if options.input_data_dir and not os.path.isdir(options.input_data_dir):
        parser.error('Given --input-data-dir does not exist or is not a directory.')
    
    if options.input_data:
        files = options.input_data
    else:
        files = get_input_data_files(options.input_data_dir)
    
    if len(files) == 0:
        parser.error("At least one input data file must be specified.")
    
    
    
    # Load all data files
    data_reports = []
    for data_file in files:
        print "Loading data file '%s'" % data_file
        data = generation_report.load_report_data(data_file)
        data_reports.append(data)
    
    # Sort by time stamp
    data_reports.sort(key=lambda entry: entry.generation_timestamp)
    
    # Generate the report
    print "Generating report to '%s'" % options.report
    generation_report.generate_report(data_reports, options.report, options.template, [ROOT_PATH], options.report_option)
    
    print "Done!'"
Пример #48
0
#-*-coding:UTF-8-*-
'''
Created on 2016年6月14日
@author: rkzhang
'''
import json, pika
from optparse import OptionParser
from pika import credentials

opt_parser = OptionParser()

opt_parser.add_options("-r", "--routing-key", dest="routing_key", help = "Routing key for message " + " (e.g. myalert.im)")

opt_parser.add_options("-m", "--message", dest="message", help="Message text for alert.")

args = opt_parser.parse_args()[0]

creds_broker = pika.PlainCredentials("sample", "sample")

conn_params = pika.ConnectionParameters("", virtual_host="/", credentials = creds_broker)

conn_broker = pika.BlockingConnection(conn_params)

channel = conn_broker.channel()

msg = json.dumps(args.message)
msg_props = pika.BasicProperties()
msg_props.content_type = "application/json"
msg_props.durable = False

channel.basic_publish(exchange, routing_key, body, properties, mandatory, immediate)
Пример #49
0
def main():
    """ Export configurations. """
    parser = OptionParser(version="%%prog %s" % VERSION)

    parser.add_options(cone_common.COMMON_OPTIONS)

    parser.add_option("-c", "--configuration",
                        dest="configs",
                        action="append",
                        help="Defines the name of the configuration for the action, can be "\
                             "specified multiple times to include multiple configurations.",
                        metavar="CONFIG",
                        default=[])

    parser.add_option("--config-wildcard",
                      action="append",
                      dest="config_wildcards",
                      help="Wildcard pattern for including configurations, e.g. "\
                           "product_langpack_*_root.confml",
                      metavar="WILDCARD",
                      default=[])

    parser.add_option("--config-regex",
                      action="append",
                      dest="config_regexes",
                      help="Regular expression for including configurations, e.g. "\
                           "product_langpack_\\d{2}_root.confml",
                      metavar="REGEX",
                      default=[])

    parser.add_option("-p", "--project",
                       dest="project",
                       help="defines the location of current project. Default is the "\
                            "current working directory.",\
                       default=".",
                       metavar="STORAGE")

    group = OptionGroup(parser, 'Export options',
                        'The export action is intended for exporting configurations '\
                        'from one project (storage) to another. A project can be a '\
                        'folder, a CPF or ZIP file, or a Carbon web storage URL. '\
                        # An ugly way to make newlines, someone should look into
                        # sub-classing optparse.HelpFormatter...


                        '                                                                          '\
                        'Two different ways of exporting are supported: '\
                        '                                                                          '\
                        '1. Exporting multiple configurations into one new project using --remote '\
                        '                                                                          '\
                        '2. Exporting configurations into a number of new projects using --export-dir')

    group.add_option("-r", "--remote",
                   dest="remote",
                   help="Defines the location of remote storage. All configurations included using "\
                        "--configuration, --config-wildcard and --config-regex are exported into "\
                        "the storage. If the remote storage location is not given, the default "\
                        "location is determined based on the first included source configuration name. "\
                        "E.g. 'example.confml' would be exported into 'example.cpf'",
                   metavar="STORAGE")

    group.add_option("--export-dir",
                     help="Defines the directory where each included configuration is exported "\
                          "as a new project.",
                     default=None)

    group.add_option("--export-format",
                     help="Defines the format into which projects are exported when using "\
                          "--export-dir. Possible values are 'cpf' (the default) and 'dir'.",
                     default=None)

    group.add_option("-a","--add",
                   dest="added",
                   action="append",
                   type="string",
                   help="Adds a configuration layer to the given configuration as last element. "\
                        "The add operation can be used several times in a single command and it "\
                        "can create even an empty layer. "\
                        "Example --add foo/root.confml --add bar/root-confml.",
                   metavar="CONFIG",
                   default=None)

    group.add_option("--run-action",
                   dest="action",
                   action="append",
                   type="string",
                   help="Adds a execution of extra step that can manipulate the configuration before it is exported to external storage. "\
                        "The --run-action operation can be used several times in a single command and it "\
                        "will execute the actions in given order."\
                        "Example --run-action=fix, which would execute fix action during export.",
                   metavar="PLUGIN",
                   default=None)

    group.add_option("--exclude-folders",
                     dest="exclude_empty_folders",
                     action="store_true",
                     help="Excludes empty folders from export",
                     default=False)

    group.add_option("--exclude-content-filter",
                        dest="exclude_content_filter",
                        help="Filters out files and folders from content folder which matches with "\
                             "the given regular expression. Matching is case-insensitive. "\
                             "Example --exclude-content-filter=\".*\.sisx|.*\.sis|.*\.wgz|.*wgt\" "\
                             "Filters out all files with extension sis, sisx, wgz or wgt.",
                        default=None)

    group.add_option("--include-content-filter",
                        dest="include_content_filter",
                        help="Filters out files and folders from content folder which don't match with "\
                             "the given regular expression. Matching is case-insensitive. "\
                             "Example --include-content-filter=\".*(manual|configurator).*\" "\
                             "Filters out all content files which don't have manual or configurator in their path.",
                        default=None)

    parser.add_option_group(group)
    (options, args) = parser.parse_args()

    cone_common.handle_common_options(options)

    # Check options
    if options.export_format and options.export_dir is None:
        parser.error(
            "--export-format can only be used in conjunction with --export-dir"
        )
    if options.export_dir and options.remote:
        parser.error(
            "--export-dir and --remote cannot be used at the same time")
    if options.export_format and options.export_format.lower() not in ('dir',
                                                                       'cpf'):
        parser.error("Invalid export format '%s'" % options.export_format)
    if options.export_dir and not (options.configs or options.config_wildcards
                                   or options.config_regexes):
        parser.error(
            "Use of --export-dir requires at least one configuration to be specified"
        )
    if options.export_dir and os.path.isfile(options.export_dir):
        parser.error("Given export directory '%s' is a file")

    try:
        run_export(options)
    except ExportFailedException, e:
        parser.error(str(e))
Пример #50
0
def getOptions():
  arguments = OptionParser()
  arguments.add_options(["--username", "--password", "--file"])
  arguments.set_default("file", "mint_backup_%s.csv" % str(date.today()))
  return arguments.parse_args()[0] # options
Пример #51
0
def getOptions():
   arguments = OptionParser()
   arguments.add_options(["--username", "--password", "--firstyear"])
   return arguments.parse_args()[0]
Пример #52
0
def main(): 
    signal.signal(signal.SIGUSR1, signal.SIG_IGN)
    if len(sys.argv)>1:  
        pid=PidContext(True)
        if sys.argv[1]=='--kill':
            if pid.signal(signal.SIGTERM):
                print("Send terminate signal")
                return
            else:
                print("Daemon not running")
                return 
        elif sys.argv[1]=='--stop':
            if pid.signal(signal.SIGUSR1):
                print("Send stop current cycle  signal")
                return
            else:
                print("Daemon not running")
                return 
            
              
    try:
        plugin=sys.argv[1]
    except :
        print('first argument must be plugin name !', file=sys.stderr)
        sys.exit(1)
    plug_module='plugins.'+plugin
    __import__(plug_module)
    plugin=sys.modules[plug_module]
    for name in plugin_points:
        if not hasattr(plugin, name):
            print('Invalid plugin - missing attribute %s'% name,  file=sys.stderr)  
            sys.exit(4)  
        
    opt_parser=OptionParser("%s plugin|--kill|--stop options directory_to_store" %sys.argv[0])
    opt_parser.add_option('--proxy', help="HTTP proxy to use, otherwise system  setting is used")
    opt_parser.add_option('--no-proxy', dest='no_proxy', action='store_true', help='Do not use proxy, even if set in system')
    opt_parser.add_option('-r', '--resume', action='store_true', help='Resumes form from last run - starts on last unfinished page '+
                          'and restores queue of unfinished downloads')
    opt_parser.add_option('-s', '--stop-after', dest='stop_after', type='int', help='Stop approximatelly after x minutes (valid only if not daemon)')
    opt_parser.add_option('-c', '--continue-after', dest='continue_after', type='int', help='Continue approximatelly after x minutes (valid only for daemon)')
    opt_parser.add_option('-d', '--debug', action='store_true', help='Debug logging')
    opt_parser.add_option('--daemon', action='store_true', help='Run as daemon')
    opt_parser.add_option('--user',  help='Run under this user')
    opt_parser.add_option('--group',  help='Run under this group')
    opt_parser.add_option('-l', '--log', help="Log file")
    
    if hasattr(plugin, 'OPTIONS'):
        opt_parser.add_options(plugin.OPTIONS)
    options,args=opt_parser.parse_args(sys.argv[2:])
    
    if len(args)<1:
        opt_parser.print_help()
        sys.exit(2)    
    
    base_dir=args[0]
    if not os.path.exists(base_dir):
        print('The output directory %s does not exists, exiting' % base_dir, file=sys.stderr)
        sys.exit(3)
    if options.daemon:
        
        def get_id(name, fn):
            if not name:
                return
            try:
                return fn(name)[2]
            except KeyError:
                pass
        
        options.stop_after=0
        try:
            pid=PidContext()
        except PidContext.AlreadyRunningError:
            print("Downloader is already running", file=sys.stderr)
            sys.exit(5)
        uid= get_id(options.user, pwd.getpwnam)
        gid = get_id(options.group, grp.getgrnam)
        
        context_args={'uid':uid, 
                      'gid':gid, 
                      'working_directory':os.getcwd(),
                      'pidfile':pid,
                      'files_preserve':[pid]}
        #context_args.update({'stdout': sys.stdout, 'stderr':sys.stderr})
        with DaemonContext(**context_args):
            init(plugin, base_dir, options)
            logging.info("Started daemon with encoding %s", sys.getdefaultencoding())
            errors=0
            while True:
                was_error=run(plugin, base_dir, options)  
                if not was_error:
                    errors=0
                    to_sleep=int(options.continue_after or 0)*60 or 3600
                    logging.info("Finished a run, will wait %d", to_sleep)
                    # run task on finish
                else:
                    errors+=1
                    limit=10
                    if errors>limit:
                        logging.error('Limit of %d fatal errors reach - stopping daemon', limit)
                        break
                    to_sleep=plugin.MAX_WAIT
                    logging.info("Finished with error will retry after %d", to_sleep)
                time.sleep(to_sleep)
    else:   
        init(plugin, base_dir, options)
        run(plugin, base_dir, options)
Пример #53
0
    def __init__(self):
        sys.excepthook = self.excepthook
        INIPATH = None
        usage = "usage: %prog [options] myfile.ui"
        parser = OptionParser(usage=usage)
        parser.disable_interspersed_args()
        parser.add_options(options)
        # remove [-ini filepath] that linuxcnc adds if being launched as a screen
        # keep a reference of that path
        for i in range(len(sys.argv)):
            if sys.argv[i] =='-ini':
                # delete -ini
                del sys.argv[i]
                # pop out the ini path
                INIPATH = sys.argv.pop(i)
                break

        (opts, args) = parser.parse_args()

        # initialize QApp so we can pop up dialogs now. 
        self.app = QtWidgets.QApplication(sys.argv)

        # we import here so that the QApp is initialized before
        # the Notify library is loaded because it uses DBusQtMainLoop
        # DBusQtMainLoop must be initialized after to work properly
        from qtvcp import qt_makepins, qt_makegui

        # ToDo: pass specific log levels as an argument, or use an INI setting
        if not opts.debug:
            # Log level defaults to DEBUG, so set higher if not debug
            logger.setGlobalLevel(logger.ERROR)

        # a specific path has been set to load from or...
        # no path set but -ini is present: default qtvcp screen...or
        # oops error
        if args:
            basepath=args[0]
        elif INIPATH:
            basepath = "qt_cnc"
        else:
            log.error('Error in path')
            sys.exit()

        # set paths using basename
        PATH = Paths(basepath, bool(INIPATH))

        #################
        # Screen specific
        #################
        if INIPATH:
            log.debug('Building A Linuxcnc Main Screen')
            import linuxcnc
            # internationalization and localization
            import locale, gettext
            # pull info from the INI file
            self.inifile = linuxcnc.ini(INIPATH)
            self.inipath = INIPATH
            # screens require more path info
            PATH.add_screen_paths()

            # International translation
            locale.setlocale(locale.LC_ALL, '')
            locale.bindtextdomain(PATH.DOMAIN, PATH.LOCALEDIR)
            gettext.install(PATH.DOMAIN, localedir=PATH.LOCALEDIR, unicode=True)
            gettext.bindtextdomain(PATH.DOMAIN, PATH.LOCALEDIR)

            # if no handler file specified, use stock test one
            if not opts.usermod:
                log.info('No handler file specified on command line')
                target =  os.path.join(PATH.CONFIGPATH, '%s_handler.py' % PATH.BASENAME)
                source =  os.path.join(PATH.SCREENDIR, 'tester/tester_handler.py')
                if PATH.HANDLER is None:
                    message = ("""
Qtvcp encountered an error; No handler file was found.
Would you like to copy a basic handler file into your config folder?
This handker file will allow display of your screen and basic keyboard jogging.

The new handlerfile's path will be:
%s

Pressing cancel will close linuxcnc.""" % target)
                    rtn = QtWidgets.QMessageBox.critical(None, "QTVCP Error", message,QtWidgets.QMessageBox.Ok | QtWidgets.QMessageBox.Cancel)
                    if rtn == QtWidgets.QMessageBox.Ok:
                        try:
                            shutil.copy(source, target)
                        except IOError as e:
                            log.critical("Unable to copy handler file. %s" % e)
                            sys.exit(0)
                        except:
                            log.critical("Unexpected error copying handler file:", sys.exc_info())
                            sys.exit(0)
                        opts.usermod = PATH.HANDLER = target
                    else:
                        log.critical('No handler file found or specified. User requested stopping')
                else:
                    opts.usermod = PATH.HANDLER

            # specify the HAL component name if missing
            if opts.component is None:
                log.info('No HAL component base name specified on command line using: {}'.format(PATH.BASENAME))
                opts.component = PATH.BASENAME

        #################
        # VCP specific
        #################
        else:
            log.debug('Building A VCP Panel')
            # if no handler file specified, use stock test one
            if not opts.usermod:
                log.info('No handler file specified - using {}'.format(PATH.HANDLER))
                opts.usermod = PATH.HANDLER

            # specify the HAL component name if missing
            if opts.component is None:
                log.info('No HAL component base name specified - using: {}'.format(PATH.BASENAME))
                opts.component = PATH.BASENAME

        ##############
        # Build ui
        ##############

        #if there was no component name specified use the xml file name
        if opts.component is None:
            opts.component = PATH.BASENAME

        # initialize HAL
        try:
            self.halcomp = hal.component(opts.component)
        except:
            log.critical("Asking for a HAL component using a name that already exists?")
            sys.exit(0)

        # initialize the window
        window = qt_makegui.MyWindow(self.halcomp, PATH)
 
        # load optional user handler file
        if opts.usermod:
            log.debug('Loading the handler file')
            window.load_extension(opts.usermod)
            # add filter to catch keyboard events
            log.debug('Adding the key events filter')
            myFilter = qt_makegui.MyEventFilter(window)
            self.app.installEventFilter(myFilter)

        # actually build the widgets
        window.instance()

        # make QT widget HAL pins
        self.panel = qt_makepins.QTPanel(self.halcomp, PATH, window, opts.debug)

        # call handler file's initialized function
        if opts.usermod:
            if "initialized__" in dir(window.handler_instance):
                log.debug('''Calling the handler file's initialized__ function''')
                window.handler_instance.initialized__()
        # All Widgets should be added now - synch them to linuxcnc
        STATUS.forced_update()

        # User components are set up so report that we are ready
        log.debug('Set HAL ready')
        self.halcomp.ready()

        # embed us into an X11 window (such as AXIS)
        if opts.parent:
            window = xembed.reparent_qt_to_x11(window, opts.parent)
            forward = os.environ.get('AXIS_FORWARD_EVENTS_TO', None)
            log.critical('Forwarding events to AXIS is not well tested yet')
            if forward:
                xembed.XEmbedFowarding(window, forward)

        # push the window id for embedment into an external program
        if opts.push_XID:
            wid = int(window.winId())
            print >> sys.stdout,wid
            sys.stdout.flush()

        # for window resize and or position options
        if "+" in opts.geometry:
            log.debug('-g option: moving window')
            try:
                j =  opts.geometry.partition("+")
                pos = j[2].partition("+")
                window.move( int(pos[0]), int(pos[2]) )
            except:
                log.critical("With window position data")
                parser.print_usage()
                sys.exit(1)
        if "x" in opts.geometry:
            log.debug('-g option: resizing')
            try:
                if "+" in opts.geometry:
                    j =  opts.geometry.partition("+")
                    t = j[0].partition("x")
                else:
                    t = window_geometry.partition("x")
                window.resize( int(t[0]), int(t[2]) )
            except:
                log.critical("With window resize data")
                parser.print_usage()
                sys.exit(1)

        # always on top
        if opts.always_top:
            window.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)

        # theme (styles in QT speak) specify a qss file
        if opts.theme:
            window.apply_styles(opts.theme)
        # appy qss file or default theme
        else:
            window.apply_styles()

        # title
        if INIPATH:
            title = 'QTvcp-Screen-%s'% opts.component
        else:
            title = 'QTvcp-Panel-%s'% opts.component
        window.setWindowTitle(title)

        log.debug('Show window')
        # maximize
        if opts.maximum:
            window.showMaximized()
        # fullscreen
        elif opts.fullscreen:
            window.showFullScreen()
        else:
            window.show()
        if INIPATH:
            self.postgui()

        # catch control c and terminate signals
        signal.signal(signal.SIGTERM, self.shutdown)
        signal.signal(signal.SIGINT, self.shutdown)

        # start loop
        self.app.exec_()

        # now shut it all down
        self.shutdown()
Пример #54
0
    def __init__(self):
        sys.excepthook = self.excepthook
        INIPATH = None
        usage = "usage: %prog [options] myfile.ui"
        parser = OptionParser(usage=usage)
        parser.disable_interspersed_args()
        parser.add_options(options)
        # remove [-ini filepath] that linuxcnc adds if being launched as a screen
        # keep a reference of that path
        for i in range(len(sys.argv)):
            if sys.argv[i] == '-ini':
                # delete -ini
                del sys.argv[i]
                # pop out the ini path
                INIPATH = sys.argv.pop(i)
                break

        (opts, args) = parser.parse_args()

        if sys.version_info.major > 2:
            # so web engine can load local images
            sys.argv.append("--disable-web-security")

        # initialize QApp so we can pop up dialogs now.
        self.app = QtWidgets.QApplication(sys.argv)

        # we import here so that the QApp is initialized before
        # the Notify library is loaded because it uses DBusQtMainLoop
        # DBusQtMainLoop must be initialized after to work properly
        from qtvcp import qt_makepins, qt_makegui

        # ToDo: pass specific log levels as an argument, or use an INI setting
        if opts.debug:
            # Log level defaults to INFO, so set lower if in debug mode
            logger.setGlobalLevel(logger.DEBUG)
        if opts.verbose:
            # Log level defaults to INFO, so set lowest if in verbose mode
            logger.setGlobalLevel(logger.VERBOSE)

        # a specific path has been set to load from or...
        # no path set but -ini is present: default qtvcp screen...or
        # oops error
        if args:
            basepath = args[0]
        elif INIPATH:
            basepath = "qt_cnc"
        else:
            PATH.set_paths()

        # set paths using basename
        PATH.set_paths(basepath, bool(INIPATH))

        # keep track of python version during this transition
        if sys.version_info.major > 2:
            ver = 'Python 3'
        else:
            ver = 'Python 2'

        #################
        # Screen specific
        #################
        if INIPATH:
            LOG.info(
                'green<Building A Linuxcnc Main Screen with {}>'.format(ver))
            import linuxcnc
            # internationalization and localization
            import locale, gettext
            # pull info from the INI file
            self.inifile = linuxcnc.ini(INIPATH)
            self.inipath = INIPATH
            # screens require more path info
            PATH.add_screen_paths()

            # International translation
            locale.setlocale(locale.LC_ALL, '')
            locale.bindtextdomain(PATH.DOMAIN, PATH.LOCALEDIR)
            gettext.install(PATH.DOMAIN, localedir=PATH.LOCALEDIR)
            gettext.bindtextdomain(PATH.DOMAIN, PATH.LOCALEDIR)

            # if no handler file specified, use stock test one
            if not opts.usermod:
                LOG.info('No handler file specified on command line')
                target = os.path.join(PATH.CONFIGPATH,
                                      '%s_handler.py' % PATH.BASENAME)
                source = os.path.join(PATH.SCREENDIR,
                                      'tester/tester_handler.py')
                if PATH.HANDLER is None:
                    message = ("""
Qtvcp encountered an error; No handler file was found.
Would you like to copy a basic handler file into your config folder?
This handler file will allow display of your screen and basic keyboard jogging.

The new handlerfile's path will be:
%s

Pressing cancel will close linuxcnc.""" % target)
                    rtn = QtWidgets.QMessageBox.critical(
                        None, "QTVCP Error", message, QtWidgets.QMessageBox.Ok
                        | QtWidgets.QMessageBox.Cancel)
                    if rtn == QtWidgets.QMessageBox.Ok:
                        try:
                            shutil.copy(source, target)
                        except IOError as e:
                            LOG.critical("Unable to copy handler file. %s" % e)
                            sys.exit(0)
                        except:
                            LOG.critical(
                                "Unexpected error copying handler file:",
                                sys.exc_info())
                            sys.exit(0)
                        opts.usermod = PATH.HANDLER = target
                    else:
                        LOG.critical(
                            'No handler file found or specified. User requested stopping'
                        )
                else:
                    opts.usermod = PATH.HANDLER

            # specify the HAL component name if missing
            if opts.component is None:
                LOG.info(
                    'No HAL component base name specified on command line using: {}'
                    .format(PATH.BASENAME))
                opts.component = PATH.BASENAME

        #################
        # VCP specific
        #################
        else:
            LOG.info('green<Building A VCP Panel with {}>'.format(ver))
            # if no handler file specified, use stock test one
            if not opts.usermod:
                LOG.info('No handler file specified - using {}'.format(
                    PATH.HANDLER))
                opts.usermod = PATH.HANDLER

            # specify the HAL component name if missing
            if opts.component is None:
                LOG.info(
                    'No HAL component base name specified - using: {}'.format(
                        PATH.BASENAME))
                opts.component = PATH.BASENAME

        ##############
        # Build ui
        ##############

        #if there was no component name specified use the xml file name
        if opts.component is None:
            opts.component = PATH.BASENAME

        # initialize HAL
        try:
            self.halcomp = hal.component(opts.component)
            self.hal = QComponent(self.halcomp)
        except:
            LOG.critical(
                "Asking for a HAL component using a name that already exists?")
            raise Exception(
                '"Asking for a HAL component using a name that already exists?'
            )

        # initialize the window
        window = qt_makegui.VCPWindow(self.hal, PATH)

        if opts.useropts:
            window.USEROPTIONS_ = opts.useropts
        else:
            window.USEROPTIONS_ = None

        # load optional user handler file
        if opts.usermod:
            LOG.debug('Loading the handler file')
            window.load_extension(opts.usermod)
            try:
                window.web_view = QWebView()
            except:
                window.web_view = None
            # do any class patching now
            if "class_patch__" in dir(window.handler_instance):
                window.handler_instance.class_patch__()
            # add filter to catch keyboard events
            LOG.debug('Adding the key events filter')
            myFilter = qt_makegui.MyEventFilter(window)
            self.app.installEventFilter(myFilter)

        # actually build the widgets
        window.instance()

        # make QT widget HAL pins
        self.panel = qt_makepins.QTPanel(self.hal, PATH, window, opts.debug)

        # call handler file's initialized function
        if opts.usermod:
            if "initialized__" in dir(window.handler_instance):
                LOG.debug(
                    '''Calling the handler file's initialized__ function''')
                window.handler_instance.initialized__()
        # All Widgets should be added now - synch them to linuxcnc
        STATUS.forced_update()

        # call a HAL file after widgets built
        if opts.halfile:
            if opts.halfile[-4:] == ".tcl":
                cmd = ["haltcl", opts.halfile]
            else:
                cmd = ["halcmd", "-f", opts.halfile]
            res = subprocess.call(cmd, stdout=sys.stdout, stderr=sys.stderr)
            if res:
                print >> sys.stderr, "'%s' exited with %d" % (' '.join(cmd),
                                                              res)
                self.shutdown()

        # User components are set up so report that we are ready
        LOG.debug('Set HAL ready')
        self.halcomp.ready()

        # embed us into an X11 window (such as AXIS)
        if opts.parent:
            window = xembed.reparent_qt_to_x11(window, opts.parent)
            forward = os.environ.get('AXIS_FORWARD_EVENTS_TO', None)
            LOG.critical('Forwarding events to AXIS is not well tested yet')
            if forward:
                xembed.XEmbedFowarding(window, forward)

        # push the window id for embedment into an external program
        if opts.push_XID:
            wid = int(window.winId())
            print >> sys.stdout, wid
            sys.stdout.flush()

        # for window resize and or position options
        if "+" in opts.geometry:
            LOG.debug('-g option: moving window')
            try:
                j = opts.geometry.partition("+")
                pos = j[2].partition("+")
                window.move(int(pos[0]), int(pos[2]))
            except Exception as e:
                LOG.critical("With -g window position data:\n {}".format(e))
                parser.print_help()
                self.shutdown()
        if "x" in opts.geometry:
            LOG.debug('-g option: resizing')
            try:
                if "+" in opts.geometry:
                    j = opts.geometry.partition("+")
                    t = j[0].partition("x")
                else:
                    t = opts.geometry.partition("x")
                window.resize(int(t[0]), int(t[2]))
            except Exception as e:
                LOG.critical("With -g window resize data:\n {}".format(e))
                parser.print_help()
                self.shutdown()

        # always on top
        if opts.always_top:
            window.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)

        # theme (styles in QT speak) specify a qss file
        if opts.theme:
            window.apply_styles(opts.theme)
        # appy qss file or default theme
        else:
            window.apply_styles()

        # title
        if INIPATH:
            title = 'QTvcp-Screen-%s' % opts.component
        else:
            title = 'QTvcp-Panel-%s' % opts.component
        window.setWindowTitle(title)

        LOG.debug('Show window')
        # maximize
        if opts.maximum:
            window.showMaximized()
        # fullscreen
        elif opts.fullscreen:
            window.showFullScreen()
        else:
            self.panel.set_preference_geometry()
        window.show()
        if INIPATH:
            self.postgui()

        # catch control c and terminate signals
        signal.signal(signal.SIGTERM, self.shutdown)
        signal.signal(signal.SIGINT, self.shutdown)

        if opts.usermod and "before_loop__" in dir(window.handler_instance):
            LOG.debug('''Calling the handler file's before_loop__ function''')
            window.handler_instance.before_loop__()

        LOG.info('Preference path: {}'.format(PATH.PREFS_FILENAME))
        # start loop
        self.app.exec_()

        # now shut it all down
        self.shutdown()
Пример #55
0
from django_nose import NoseTestSuiteRunner

if django.VERSION >= (1, 7):
    # New Apps loading mechanism
    django.setup()

def runtests(*test_args, **kwargs):
    if 'south' in settings.INSTALLED_APPS:
        from south.management.commands import patch_for_test_db_setup
        patch_for_test_db_setup()

    if not test_args:
        test_args = ['celery_rpc']

    test_runner = NoseTestSuiteRunner(**kwargs)

    failures = test_runner.run_tests(test_args)
    sys.exit(failures)

if __name__ == '__main__':
    parser = OptionParser()
    parser.add_option('--verbosity', dest='verbosity', action='store',
                      default=1, type=int)
    opts = getattr(NoseTestSuiteRunner, 'options', None)
    if opts:
        parser.add_options(opts)
    (options, args) = parser.parse_args()

    runtests(*args, **options.__dict__)