コード例 #1
0
def main():
    if is_manager_dbus_running():
        return
    app = QtCore.QCoreApplication(sys.argv)
    app.setApplicationName(_(constants.APP_NAME))
    manager_dbus = ManagerDBus()
    app.exec()
コード例 #2
0
def main():

    args = parse_args()

    # Try to connect to the GPU backend
    app = QtCore.QCoreApplication([])

    # Start the GPU backend
    cmdline = [GPUSIM_EXEC]
    if args.cpu_only:
        cmdline.append('--cpu_only')
    cmdline += ['--gpu_bitcount', args.gpu_bitcount]
    cmdline += args.dbnames
    backend_proc = subprocess.Popen(cmdline)
    setup_socket(app)

    if args.http_interface:
        handler = GPUSimHTTPHandler
    else:
        handler = GPUSimHandler
    server = ThreadedHTTPServer((args.hostname, args.port), handler)
    print("Running HTTP server...", file=sys.stderr)
    try:
        server.serve_forever()
    finally:
        backend_proc.kill()
コード例 #3
0
 def current(session: Session):
     """
     Retrieve the checked-in User instance.
     If the User doesn't exist in the sessions database,
     and there isn't a conflict, this method will create it.
     """
     app = QtCore.QCoreApplication.instance() or QtCore.QCoreApplication(sys.argv)
     settings = QtCore.QSettings(ORG_NAME, APP_NAME)
     name = settings.value('User.name', None)
     uid = settings.value('User.uid', None)
     if None in (name, uid):
         raise EnvironmentError('No user is currently checked-in.')
     try:
         user = session.query(User)\
                 .filter(User.name.ilike(name), User.uid == uid).one()
     except NoResultFound:
         same_name = session.query(User)\
                 .filter(User.name.ilike(name)).count()
         same_uid = session.query(User).filter(User.uid == uid).count()
         if same_name or same_uid:
             raise ValueError(
                 f'User name/uid mismatch.\n'
                 f'{same_name} user{"s" if same_name != 1 else ""} have the '
                 f'same name : {name}\n'
                 f'{same_uid} user{"s" if same_uid != 1 else ""} have the '
                 f'same unique id : {uid}'
             )
         user = User(name=name, uid=uid)
         session.add(user)
         session.commit()
     return user
コード例 #4
0
ファイル: main2.py プロジェクト: LEPPEDIAZ/ProyectoHCI
 def music(self):
     app = QtCore.QCoreApplication(sys.argv)
     url = QtCore.QUrl.fromLocalFile("./fairydust.mp3")
     content = M.QMediaContent(url)
     player = M.QMediaPlayer()
     player.setMedia(content)
     player.play()
コード例 #5
0
ファイル: Qt.py プロジェクト: xtoof/maya-capture-gui
def pyside():
    import PySide
    from PySide import QtGui, QtCore, QtUiTools

    remap(PySide, "QtWidgets", QtGui)
    remap(QtCore, "QSortFilterProxyModel", QtGui.QSortFilterProxyModel)
    remap(QtCore, "QStringListModel", QtGui.QStringListModel)
    remap(QtCore, "QItemSelection", QtGui.QItemSelection)
    remap(QtCore, "QItemSelectionModel", QtGui.QItemSelectionModel)
    remap(QtCore, "QAbstractProxyModel", QtGui.QAbstractProxyModel)

    try:
        from PySide import QtWebKit
        remap(PySide, "QtWebKitWidgets", QtWebKit)
    except ImportError:
        # QtWebkit is optional in Qt , therefore might not be available
        pass

    add(PySide, "__wrapper_version__", __version__)
    add(PySide, "__binding__", "PySide")
    add(PySide, "__binding_version__", PySide.__version__)
    add(PySide, "__qt_version__", PySide.QtCore.qVersion())
    add(PySide, "__added__", __added__)
    add(PySide, "__remapped__", __remapped__)
    add(PySide, "__modified__", __modified__)
    add(PySide, "load_ui", lambda fname: QtUiTools.QUiLoader().load(fname))
    add(PySide, "convert", convert)
    add(PySide, "translate", lambda
        context, sourceText, disambiguation, n: QtCore.QCoreApplication(
            context, sourceText, disambiguation, None, n))

    return PySide
コード例 #6
0
def main():

    args = parse_args()
    db = args.dbnames
    #all_dbs = args.dbnames
    f = open(args.sm_file)
    mol_list = []
    for line in f:
        mol_list.append(line[:-1])
    similarity_cutoff = args.cutoff
    return_count = args.return_count
    # Try to connect to the GPU backend
    app = QtCore.QCoreApplication([])
    cmdline = [GPUSIM_EXEC]
    cmdline += ['--gpu_bitcount', args.gpu_bitcount]
    cmdline += db
    backend_proc = subprocess.Popen(cmdline, stdout=subprocess.PIPE)
    setup_socket(app)
    output = backend_proc.stdout.readline()
    if os.path.exists(args.res_file):
        f = open(args.res_file, "a")
    else:
        f = open(args.res_file, "w")
        f.writelines("src_smiles,result,similarity,db_id\n")
    for mol in mol_list:
        print(mol)
        approximate_results, smiles, ids, scores, src_smiles = \
        search_for_results(mol, return_count, similarity_cutoff, ["default"], [""])
        print("Results: ", approximate_results)
        if len(smiles) > 0:
            for i in range(len(smiles)):
                f.writelines(src_smiles + "," + smiles[i] + "," + str(scores[i]) + "," + str(ids[i]) + "\n")
    f.close()
    backend_proc.kill()
コード例 #7
0
def main():
    args = parse_args()
    app = QtCore.QCoreApplication([])

    socket = QtNetwork.QLocalSocket(app)
    smiles = input("Smiles: ")
    dbcount = 1
    dbname = args.dbname
    dbkey = args.dbkey
    socket.connectToServer('gpusimilarity')

    while smiles and smiles.lower() not in ('quit', 'exit'):
        return_count = 20
        similarity_cutoff = 0

        fp_binary, _ = smiles_to_fingerprint_bin(smiles)
        fp_qba = QtCore.QByteArray(fp_binary)

        output_qba = QtCore.QByteArray()
        output_qds = QtCore.QDataStream(output_qba, QtCore.QIODevice.WriteOnly)

        output_qds.writeInt(dbcount)
        output_qds.writeString(dbname.encode())
        output_qds.writeString(dbkey.encode())

        request_num = random.randint(0, 2**31)
        output_qds.writeInt(request_num)
        output_qds.writeInt(return_count)
        output_qds.writeFloat(similarity_cutoff)
        output_qds << fp_qba

        socket.write(output_qba)
        socket.flush()
        socket.waitForReadyRead(30000)
        output_qba = socket.readAll()

        smiles = []
        scores = []
        ids = []

        data_reader = QtCore.QDataStream(output_qba)
        returned_request = data_reader.readInt()
        if request_num != returned_request:
            raise RuntimeError("Incorrect result ID returned!")

        return_count = data_reader.readInt()
        approximate_matches = data_reader.readUInt64()

        for i in range(return_count):
            smiles.append(data_reader.readString())
        for i in range(return_count):
            ids.append(data_reader.readString())
        for i in range(return_count):
            scores.append(data_reader.readFloat())

        print("Approximate total matches: {0}, returning {1}".format(
            approximate_matches, return_count))
        for cid, smi, score in zip(ids, smiles, scores):
            print("{0} {1}: {2}".format(cid, smi, score))
        smiles = input("Smiles: ")
コード例 #8
0
def main():

    global sockets
    args = parse_args()

    # Try to connect to the GPU backend
    app = QtCore.QCoreApplication([])

    procs = []
    for dbname in args.dbnames:
        # Start the GPU backend
        cmdline = [FASTSIM_EXEC, dbname]
        if args.cpu_only:
            cmdline.append('--cpu_only')
        procs.append(subprocess.Popen(cmdline))
        socket = QtNetwork.QLocalSocket(app)
        dbname_noext = os.path.splitext(os.path.basename(dbname))[0]
        sockets[dbname_noext] = socket
        while not socket.isValid():
            socket_name = os.path.splitext(os.path.basename(dbname))[0]
            socket.connectToServer(socket_name)
            time.sleep(0.3)

    if args.http_interface:
        handler = FastSimHTTPHandler
    else:
        handler = FastSimHandler
    server = ThreadedHTTPServer((args.hostname, args.port), handler)
    print("Running HTTP server...")
    server.serve_forever()
    for proc in procs:
        proc.kill()
コード例 #9
0
ファイル: Qt.py プロジェクト: sniler/pipeline
def _pyside():
    import PySide
    from PySide import QtGui, QtCore, QtUiTools

    _remap(PySide, "QtWidgets", QtGui)
    _remap(QtCore, "QSortFilterProxyModel", QtGui.QSortFilterProxyModel)
    _remap(QtCore, "QStringListModel", QtGui.QStringListModel)
    _remap(QtCore, "QItemSelection", QtGui.QItemSelection)
    _remap(QtCore, "QItemSelectionModel", QtGui.QItemSelectionModel)
    _remap(QtCore, "QAbstractProxyModel", QtGui.QAbstractProxyModel)

    try:
        from PySide import QtWebKit
        _remap(PySide, "QtWebKitWidgets", QtWebKit)
    except ImportError:
        # QtWebkit is optional in Qt, therefore might not be available
        pass

    _add(PySide, "__binding__", PySide.__name__)
    _add(PySide, "load_ui", lambda fname: QtUiTools.QUiLoader().load(fname))
    _add(PySide, "translate", lambda context, sourceText, disambiguation, n: (
        QtCore.QCoreApplication(context, sourceText,
                                disambiguation, None, n)))
    _add(PySide, "setSectionResizeMode", QtGui.QHeaderView.setResizeMode)

    _maintain_backwards_compatibility(PySide)

    return PySide
コード例 #10
0
def main():
    import sys
    app = QtCore.QCoreApplication(sys.argv)
    from artisanlib.acaia import AcaiaBLE
    acaia = AcaiaBLE()
    ble = BleInterface(acaia.SERVICE_UUID,acaia.CHAR_UUID,acaia.processData,acaia.sendHeartbeat,acaia.sendStop,acaia.reset)
    ble.scanDevices()
    sys.exit(app.exec_())
コード例 #11
0
ファイル: music.py プロジェクト: LEPPEDIAZ/ProyectoHCI
    def __init__(self):
        super().__init__()
        self.music = C.QCoreApplication(sys.argv)

        url = C.QUrl.fromLocalFile("./orange.mp3")
        content = M.QMediaContent(url)
        self.player = M.QMediaPlayer()
        self.player.setMedia(content)
        self.player.play()
コード例 #12
0
def main():
    if is_server_dbus_running():
        print('server dbus is running, ignore')
        return
    server_dbus = ServerDBus()
    # FIXME: log service failed to dump log
    server_log.debug('Init server dbus: %s' % server_dbus)
    print('server dbus inited')
    app = QtCore.QCoreApplication(sys.argv)
    app.exec()
コード例 #13
0
    def setUp(self):
        """
        We need to setup a QCoreApplication because the QThread stuff expects
        an event loop to be present. Since we never start the event loop we
        need to process events manually.

        """
        self.app = QtCore.QCoreApplication([])
        self.fdsnws_runner = FDSNWSRunner(None)
        self.fdsnws_runner._importer._run = mock_run
コード例 #14
0
 def test_close(self):
     """ Test if closing the project emits the will_close signal """
     app = QtCore.QCoreApplication([])
     mock_store = MagicMock()
     mock_signal_handler = MagicMock()
     project = Project(mock_store)
     project.will_close.connect(mock_signal_handler)
     project.close()
     app.processEvents()
     mock_signal_handler.assert_called_once_with(project)
コード例 #15
0
 def nextpage(self):
     self.count += 1
     print(self.count)
     if self.count == 1:
         self.screen.setPixmap(QtGui.QPixmap("img/sc2.png"))
     elif self.count == 2:
         app = QtCore.QCoreApplication([])
         #start_timer(timer_func, 10)
         self.show_icon()
     elif self.count == 3:
         self.screen.setPixmap(QtGui.QPixmap("img/screen.png"))
コード例 #16
0
    def test_update_project_time(self):
        """ Test if the project_time_changed signal is emitted as expected """
        self.project = Project(self.store_mock)
        app = QtCore.QCoreApplication([])
        handler = MagicMock()
        self.project.project_time_changed.connect(handler)
        t = datetime(2020, 1, 1, 17)

        self.project.update_project_time(t)
        app.processEvents()
        handler.assert_called_once_with(t)
コード例 #17
0
 def check_in(name: str, uid: bytes):
     """
     Gets or creates a User and returns the instance.
     User names for identifying edits, and not keeping people from
     reading our data.
     Raises an exception if the name and uid do not match.
     """
     app = QtCore.QCoreApplication.instance() or QtCore.QCoreApplication(sys.argv)
     settings = QtCore.QSettings(ORG_NAME, APP_NAME)
     settings.setValue('User.name', name)
     settings.setValue('User.uid', uid)
コード例 #18
0
ファイル: Qt.py プロジェクト: xtoof/maya-capture-gui
def pyqt4():
    # Attempt to set sip API v2 (must be done prior to importing PyQt4)
    import sip
    try:
        sip.setapi("QString", 2)
        sip.setapi("QVariant", 2)
        sip.setapi("QDate", 2)
        sip.setapi("QDateTime", 2)
        sip.setapi("QTextStream", 2)
        sip.setapi("QTime", 2)
        sip.setapi("QUrl", 2)
    except AttributeError:
        raise ImportError
        # PyQt4 < v4.6
    except ValueError:
        # API version already set to v1
        raise ImportError

    import PyQt4.Qt
    from PyQt4 import QtCore, QtGui, uic

    remap(PyQt4, "QtWidgets", QtGui)
    remap(QtCore, "Signal", QtCore.pyqtSignal)
    remap(QtCore, "Slot", QtCore.pyqtSlot)
    remap(QtCore, "Property", QtCore.pyqtProperty)
    remap(QtCore, "QItemSelection", QtGui.QItemSelection)
    remap(QtCore, "QStringListModel", QtGui.QStringListModel)
    remap(QtCore, "QItemSelectionModel", QtGui.QItemSelectionModel)
    remap(QtCore, "QSortFilterProxyModel", QtGui.QSortFilterProxyModel)
    remap(QtCore, "QAbstractProxyModel", QtGui.QAbstractProxyModel)

    try:
        from PyQt4 import QtWebKit
        remap(PyQt4, "QtWebKitWidgets", QtWebKit)
    except ImportError:
        # QtWebkit is optional in Qt , therefore might not be available
        pass

    add(PyQt4, "__wrapper_version__", __version__)
    add(PyQt4, "__binding__", "PyQt4")
    add(PyQt4, "__binding_version__", QtCore.PYQT_VERSION_STR)
    add(PyQt4, "__qt_version__", QtCore.QT_VERSION_STR)
    add(PyQt4, "__added__", __added__)
    add(PyQt4, "__remapped__", __remapped__)
    add(PyQt4, "__modified__", __modified__)
    add(PyQt4, "load_ui", lambda fname: uic.loadUi(fname))
    add(PyQt4, "convert", convert)
    add(PyQt4, "translate", lambda
        context, sourceText, disambiguation, n: QtCore.QCoreApplication(
            context, sourceText, disambiguation, None, n))

    return PyQt4
コード例 #19
0
def create_QApplication():
    QtCore.QThread.currentThread().setObjectName("MAIN")  # For DEBUG info
    app = 0  # Work-around for kernel crash when using Spyder IDE
    # QtWidgets are not needed for pytest and will fail standard Travis test
    # app = QtWidgets.QApplication(sys.argv)
    app = QtCore.QCoreApplication(sys.argv)  # Use QCoreApplication instead

    global cnt_DAQ_updated, cnt_DAQ_paused, cnt_jobs_updated
    cnt_DAQ_updated = 0
    cnt_DAQ_paused = 0
    cnt_jobs_updated = 0

    return app
コード例 #20
0
def main():
    """
    This script allows you to run this module as a standalone Python program.
    """
    app = QtCore.QCoreApplication([])

    inf = input('Input file: ')
    outf = input('Output file: ')

    with open(inf, 'rb') as inf:
        inb = inf.read()

    outImg = renderGTX(loadGTX(inb))
    outImg.save(outf)
コード例 #21
0
ファイル: Qt.py プロジェクト: mikepkes/Rv_Python_terminal
def _pyqt4():
    # Attempt to set sip API v2 (must be done prior to importing PyQt4)
    import sip
    try:
        sip.setapi("QString", 2)
        sip.setapi("QVariant", 2)
        sip.setapi("QDate", 2)
        sip.setapi("QDateTime", 2)
        sip.setapi("QTextStream", 2)
        sip.setapi("QTime", 2)
        sip.setapi("QUrl", 2)
    except AttributeError:
        raise ImportError
        # PyQt4 < v4.6
    except ValueError:
        # API version already set to v1
        raise ImportError

    import PyQt4.Qt
    from PyQt4 import QtCore, QtGui, uic

    _remap(PyQt4, "QtWidgets", QtGui)
    _remap(QtCore, "Signal", QtCore.pyqtSignal)
    _remap(QtCore, "Slot", QtCore.pyqtSlot)
    _remap(QtCore, "Property", QtCore.pyqtProperty)
    _remap(QtCore, "QItemSelection", QtGui.QItemSelection)
    _remap(QtCore, "QStringListModel", QtGui.QStringListModel)
    _remap(QtCore, "QItemSelectionModel", QtGui.QItemSelectionModel)
    _remap(QtCore, "QSortFilterProxyModel", QtGui.QSortFilterProxyModel)
    _remap(QtCore, "QAbstractProxyModel", QtGui.QAbstractProxyModel)

    try:
        from PyQt4 import QtWebKit
        _remap(PyQt4, "QtWebKitWidgets", QtWebKit)
    except ImportError:
        # QtWebkit is optional in Qt , therefore might not be available
        pass

    _add(PyQt4, "QtCompat", self)
    _add(PyQt4, "__binding__", PyQt4.__name__)
    _add(PyQt4, "load_ui", lambda fname: uic.loadUi(fname))
    _add(
        PyQt4, "translate", lambda context, sourceText, disambiguation, n:
        (QtCore.QCoreApplication(context, sourceText, disambiguation, None, n)
         ))
    _add(PyQt4, "setSectionResizeMode", QtGui.QHeaderView.setResizeMode)

    _maintain_backwards_compatibility(PyQt4)

    return PyQt4
コード例 #22
0
ファイル: 200701-01-media-sound.py プロジェクト: a3040/pyqt5
def main():
    filename = os.path.join(CURRENT_DIR, "sound.mp3")

    app = QtCore.QCoreApplication(sys.argv)

    player = QtMultimedia.QMediaPlayer()

    url = QtCore.QUrl.fromLocalFile(filename)
    player.setMedia(QtMultimedia.QMediaContent(url))
    player.play()

    # end in 5 seconds:
    QtCore.QTimer.singleShot(5 * 1000, app.quit)

    sys.exit(app.exec_())
コード例 #23
0
ファイル: nuevointento.py プロジェクト: LEPPEDIAZ/ProyectoHCI
    def __init__(self):
        super().__init__()
        self.music = C.QCoreApplication(sys.argv)

        url = C.QUrl.fromLocalFile("./orange.mp3")
        content = M.QMediaContent(url)
        self.player = M.QMediaPlayer()
        self.player.setMedia(content)
        self.player.play()
        self.title = 'PyQt absolute positioning - pythonspot.com'
        self.left = 10
        self.top = 10
        self.width = 440
        self.height = 280
        self.initUI()
コード例 #24
0
ファイル: lib.py プロジェクト: mkolar/pyblish-qml
def _setup():
    if self.app is None:
        self.app = QtCore.QCoreApplication.instance()

    if self.app is None:
        self.app = QtCore.QCoreApplication(sys.argv)

    service = pyblish_rpc.service.RpcService()
    self.server = pyblish_rpc.server._server(self.port, service)

    self.thread = threading.Thread(target=self.server.serve_forever)

    self.thread.daemon = True
    self.thread.start()

    clean()
コード例 #25
0
    def setUp(self):
        """
        Test Preparation

        The simulator should deliver the time change signal in intervals of
        one second divided by TEST_SPEED.
        Since the simulator delivers event through the QtCore event loop, we
        need to setup a qt application.

        """
        self.app = QtCore.QCoreApplication([])
        self.history = []
        self.time_step = 1 / TEST_SPEED
        self.simulator = Simulator(self._callback)
        # state variables
        self.simulation_time = None
        self.t_elapsed = 0
コード例 #26
0
    def run(self):
        """
        Runs the server process by starting its own QCoreApplication.
        """
        # because PyQt5 eats exceptions in the event thread this workaround
        sys.excepthook = start.exception_hook

        app = QtCore.QCoreApplication([])

        # server manager, signal shutdown stops the app
        server_manager = ServerManager()
        server_manager.shutdown.connect(app.quit)
        # noinspection PyCallByClass
        QtCore.QTimer.singleShot(100, server_manager.start)

        # run event loop of app
        app.exec_()
コード例 #27
0
    def run(self):
        """
        Runs the server process by starting its own QCoreApplication.
        """
        self._configure_forked_logger()

        qt.fix_pyqt5_exception_eating()

        app = QtCore.QCoreApplication([])

        # server manager, signal shutdown stops the app
        server_manager = ServerManager()
        server_manager.shutdown.connect(app.quit)
        # noinspection PyCallByClass
        QtCore.QTimer.singleShot(100, server_manager.start)

        # run event loop of app
        app.exec_()
コード例 #28
0
ファイル: Qt.py プロジェクト: sniler/pipeline
def _pyside2():
    import PySide2
    from PySide2 import QtGui, QtWidgets, QtCore, QtUiTools

    _remap(QtCore, "QStringListModel", QtGui.QStringListModel)

    _add(PySide2, "__binding__", PySide2.__name__)
    _add(PySide2, "load_ui", lambda fname: QtUiTools.QUiLoader().load(fname))
    _add(PySide2, "translate", lambda context, sourceText, disambiguation, n: (
        QtCore.QCoreApplication(context, sourceText,
                                disambiguation, None, n)))
    _add(PySide2,
         "setSectionResizeMode",
         QtWidgets.QHeaderView.setSectionResizeMode)

    _maintain_backwards_compatibility(PySide2)

    return PySide2
コード例 #29
0
    def __init__(self, args):
        """
        Instantiates the Ramsis core and the Qt app (run loop) and
        wires the GUI.

        :param args: command line arguments that were provided by the user

        """
        super().__init__()
        self.thread().setObjectName('Main')
        # Setup the logger
        self.logger = logging.getLogger(__name__)
        self.logger.info('Launching RAMSIS v' + VERSION)
        # Instantiate the appropriate Qt app object
        self.has_gui = not args.no_gui
        if self.has_gui:
            # QApplication.setStyle(
            #     QStyleFactory.create('Cleanlooks'))
            self.qt_app = QApplication(sys.argv)
            # QgsApplication.initQgis()
        else:
            self.qt_app = QtCore.QCoreApplication(sys.argv)
        # Register some general app information
        self.qt_app.setApplicationName('Ramsis')
        self.qt_app.setOrganizationDomain('seismo.ethz.ch')
        self.qt_app.setApplicationVersion(VERSION)
        self.qt_app.setOrganizationName('SED')
        # Load settings
        path = args.config if args.config else 'ramsis.ini'
        settings_file = os.path.abspath(path)
        self.app_settings = AppSettings(settings_file)
        # Enable Ctrl-C
        signal.signal(signal.SIGINT, self._on_sigint)
        # Once the Qt event loop is running, we need a timer to periodically
        # run the Python interpreter so it can process Ctrl-C signals
        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(lambda: None)
        self.timer.start(500)
        # Launch core
        self.ramsis_core = Controller(settings=self.app_settings)
        if self.has_gui:
            self.main_window = MainWindow(self)
        self.app_launched.connect(self.on_app_launched)
コード例 #30
0
ファイル: Qt.py プロジェクト: mikepkes/Rv_Python_terminal
def _pyqt5():
    import PyQt5.Qt
    from PyQt5 import QtCore, QtWidgets, uic

    _remap(QtCore, "Signal", QtCore.pyqtSignal)
    _remap(QtCore, "Slot", QtCore.pyqtSlot)
    _remap(QtCore, "Property", QtCore.pyqtProperty)

    _add(PyQt5, "__binding__", PyQt5.__name__)
    _add(PyQt5, "load_ui", lambda fname: uic.loadUi(fname))
    _add(
        PyQt5, "translate", lambda context, sourceText, disambiguation, n:
        (QtCore.QCoreApplication(context, sourceText, disambiguation, n)))
    _add(PyQt5, "setSectionResizeMode",
         QtWidgets.QHeaderView.setSectionResizeMode)

    _maintain_backwards_compatibility(PyQt5)

    return PyQt5