def main():
if is_manager_dbus_running():
return
app = QtCore.QCoreApplication(sys.argv)
app.setApplicationName(_(constants.APP_NAME))
manager_dbus = ManagerDBus()
app.exec()
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()
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
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()
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
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()
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: ")
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()
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
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_())
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()
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()
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
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)
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"))
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)
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)
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
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
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)
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
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_())
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()
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()
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
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_()
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_()
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
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)
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
