本文整理汇总了Python中qtpy.QtCore.QTimer.stop方法的典型用法代码示例。如果您正苦于以下问题:Python QTimer.stop方法的具体用法?Python QTimer.stop怎么用?Python QTimer.stop使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类qtpy.QtCore.QTimer
的用法示例。
在下文中一共展示了QTimer.stop方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: MatplotlibDataViewer
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
class MatplotlibDataViewer(MatplotlibViewerMixin, DataViewer):
_state_cls = MatplotlibDataViewerState
tools = ['mpl:home', 'mpl:pan', 'mpl:zoom']
subtools = {'save': ['mpl:save']}
def __init__(self, session, parent=None, wcs=None, state=None):
super(MatplotlibDataViewer, self).__init__(session, parent=parent, state=state)
# Use MplWidget to set up a Matplotlib canvas inside the Qt window
self.mpl_widget = MplWidget()
self.setCentralWidget(self.mpl_widget)
# TODO: shouldn't have to do this
self.central_widget = self.mpl_widget
self.figure, self.axes = init_mpl(self.mpl_widget.canvas.fig, wcs=wcs)
MatplotlibViewerMixin.setup_callbacks(self)
self.central_widget.resize(600, 400)
self.resize(self.central_widget.size())
self._monitor_computation = QTimer()
self._monitor_computation.setInterval(500)
self._monitor_computation.timeout.connect(self._update_computation)
def _update_computation(self, message=None):
# If we get a ComputationStartedMessage and the timer isn't currently
# active, then we start the timer but we then return straight away.
# This is to avoid showing the 'Computing' message straight away in the
# case of reasonably fast operations.
if isinstance(message, ComputationStartedMessage):
if not self._monitor_computation.isActive():
self._monitor_computation.start()
return
for layer_artist in self.layers:
if layer_artist.is_computing:
self.loading_rectangle.set_visible(True)
text = self.loading_text.get_text()
if text.count('.') > 2:
text = 'Computing'
else:
text += '.'
self.loading_text.set_text(text)
self.loading_text.set_visible(True)
self.redraw()
return
self.loading_rectangle.set_visible(False)
self.loading_text.set_visible(False)
self.redraw()
# If we get here, the computation has stopped so we can stop the timer
self._monitor_computation.stop()
示例2: BaseTimerStatus
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
class BaseTimerStatus(StatusBarWidget):
"""Status bar widget base for widgets that update based on timers."""
def __init__(self, parent, statusbar):
"""Status bar widget base for widgets that update based on timers."""
self.timer = None # Needs to come before parent call
super(BaseTimerStatus, self).__init__(parent, statusbar)
self._interval = 2000
# Widget setup
fm = self.label_value.fontMetrics()
self.label_value.setMinimumWidth(fm.width('000%'))
# Setup
if self.is_supported():
self.timer = QTimer()
self.timer.timeout.connect(self.update_status)
self.timer.start(self._interval)
else:
self.hide()
def setVisible(self, value):
"""Override Qt method to stops timers if widget is not visible."""
if self.timer is not None:
if value:
self.timer.start(self._interval)
else:
self.timer.stop()
super(BaseTimerStatus, self).setVisible(value)
def set_interval(self, interval):
"""Set timer interval (ms)."""
self._interval = interval
if self.timer is not None:
self.timer.setInterval(interval)
def import_test(self):
"""Raise ImportError if feature is not supported."""
raise NotImplementedError
def is_supported(self):
"""Return True if feature is supported."""
try:
self.import_test()
return True
except ImportError:
return False
def get_value(self):
"""Return formatted text value."""
raise NotImplementedError
def update_status(self):
"""Update status label widget, if widget is visible."""
if self.isVisible():
self.label_value.setText(self.get_value())
示例3: DelayJobRunner
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
class DelayJobRunner(object):
"""
Utility class for running job after a certain delay.
If a new request is made during this delay, the previous request is dropped
and the timer is restarted for the new request.
We use this to implement a cooldown effect that prevents jobs from being
executed while the IDE is not idle.
A job is a simple callable.
"""
def __init__(self, delay=500):
"""
:param delay: Delay to wait before running the job. This delay applies
to all requests and cannot be changed afterwards.
"""
self._timer = QTimer()
self.delay = delay
self._timer.timeout.connect(self._exec_requested_job)
self._args = []
self._kwargs = {}
self._job = lambda x: None
def request_job(self, job, *args, **kwargs):
"""
Request a job execution.
The job will be executed after the delay specified in the
DelayJobRunner contructor elapsed if no other job is requested until
then.
:param job: job.
:type job: callable
:param args: job's position arguments
:param kwargs: job's keyworded arguments
"""
self.cancel_requests()
self._job = job
self._args = args
self._kwargs = kwargs
self._timer.start(self.delay)
def cancel_requests(self):
"""Cancels pending requests."""
self._timer.stop()
self._job = None
self._args = None
self._kwargs = None
def _exec_requested_job(self):
"""Execute the requested job after the timer has timeout."""
self._timer.stop()
self._job(*self._args, **self._kwargs)
示例4: TasksInProcess
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
class TasksInProcess(TasksBase):
"""Implements a queue containing jobs (Python methods of a base class
specified in `cls`)."""
def init_queues(self):
self._qin = pQueue()
self._qout = pQueue()
self._qout_sync = pQueue()
def instanciate_task(self):
self.task_obj = ToInstanciate(self.task_class, *self.initargs, **self.initkwargs)
# This object resides on the master process.
self.task_obj_master = self.task_class(*self.initargs,
**self.initkwargs)
def start(self):
self.start_worker()
self.start_master()
def start_worker(self):
"""Start the worker thread or process."""
self._process_worker = Process(target=worker_loop, args=(self.task_obj,
self._qin, self._qout, self._qout_sync, self.impatient))
self._process_worker.start()
def _retrieve(self):
"""Master main function."""
if self.use_master_thread:
master_loop(self.task_class, self._qin, self._qout, self.results,
task_obj=self.task_obj_master)
else:
master_iteration(self.task_class, self._qin, self._qout, self.results,
task_obj=self.task_obj_master)
def start_master(self):
"""Start the master thread, used to retrieve the results."""
if self.use_master_thread:
self._thread_master = _start_thread(self._retrieve)
else:
self._timer_master = QTimer(self)
self._timer_master.setInterval(int(TIMER_MASTER_DELAY * 1000))
self._timer_master.timeout.connect(self._retrieve)
self._timer_master.start()
def join(self):
"""Stop the worker and master as soon as all tasks have finished."""
self._qin.put(FINISHED)
if self.use_master_thread:
self._thread_master.join()
else:
self._timer_master.stop()
self._process_worker.terminate()
self._process_worker.join()
def terminate(self):
self._process_worker.terminate()
self._process_worker.join()
self._qout.put(FINISHED)
if self.use_master_thread:
self._thread_master.join()
else:
self._timer_master.stop()
def __getattr__(self, name):
# execute a method on the task object locally
task_obj = self.task_obj_master
# if hasattr(self.task_class, name):
if hasattr(task_obj, name):
v = getattr(task_obj, name)
# wrap the task object's method in the Job Queue so that it
# is pushed in the queue instead of executed immediately
if inspect.ismethod(v):
return lambda *args, **kwargs: self._put(name, *args, **kwargs)
# if the attribute is a task object's property, just return it
else:
return v
# or, if the requested name is a task object attribute, try obtaining
# remotely
else:
result = self._put('__getattribute__', name, _sync=True)
return result[2]['_result']
示例5: AutosaveForPlugin
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
class AutosaveForPlugin(object):
"""Component of editor plugin implementing autosave functionality."""
# Interval (in ms) between two autosaves
DEFAULT_AUTOSAVE_INTERVAL = 60 * 1000
def __init__(self, editor):
"""
Constructor.
Autosave is disabled after construction and needs to be enabled
explicitly if required.
Args:
editor (Editor): editor plugin.
"""
self.editor = editor
self.timer = QTimer(self.editor)
self.timer.setSingleShot(True)
self.timer.timeout.connect(self.do_autosave)
self._enabled = False # Can't use setter here
self._interval = self.DEFAULT_AUTOSAVE_INTERVAL
@property
def enabled(self):
"""
Get or set whether autosave component is enabled.
The setter will start or stop the autosave component if appropriate.
"""
return self._enabled
@enabled.setter
def enabled(self, new_enabled):
if new_enabled == self.enabled:
return
self.stop_autosave_timer()
self._enabled = new_enabled
self.start_autosave_timer()
@property
def interval(self):
"""
Interval between two autosaves, in milliseconds.
The setter will perform an autosave if the interval is changed and
autosave is enabled.
"""
return self._interval
@interval.setter
def interval(self, new_interval):
if new_interval == self.interval:
return
self.stop_autosave_timer()
self._interval = new_interval
if self.enabled:
self.do_autosave()
def start_autosave_timer(self):
"""
Start a timer which calls do_autosave() after `self.interval`.
The autosave timer is only started if autosave is enabled.
"""
if self.enabled:
self.timer.start(self.interval)
def stop_autosave_timer(self):
"""Stop the autosave timer."""
self.timer.stop()
def do_autosave(self):
"""Instruct current editorstack to autosave files where necessary."""
logger.debug('Autosave triggered')
stack = self.editor.get_current_editorstack()
stack.autosave.autosave_all()
self.start_autosave_timer()
def try_recover_from_autosave(self):
"""Offer to recover files from autosave."""
autosave_dir = get_conf_path('autosave')
autosave_mapping = CONF.get('editor', 'autosave_mapping', {})
dialog = RecoveryDialog(autosave_dir, autosave_mapping,
parent=self.editor)
dialog.exec_if_nonempty()
self.recover_files_to_open = dialog.files_to_open[:]
示例6: ScriptRunner
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
class ScriptRunner(object):
"""
Runs a script that interacts with a widget (tests it).
If the script is a python generator then after each iteration controls returns
to the QApplication's event loop.
Generator scripts can yield a positive number. It is treated as the number of seconds
before the next iteration is called. During the wait time the event loop is running.
"""
def __init__(self, script, widget=None, close_on_finish=True, pause=0, is_cli=False):
"""
Initialise a runner.
:param script: The script to run.
:param widget: The widget to test.
:param close_on_finish: If true close the widget after the script has finished.
:param is_cli: If true the script is to be run from a command line tool. Exceptions are
treated slightly differently in this case.
"""
app = get_application()
self.script = script
self.widget = widget
self.close_on_finish = close_on_finish
self.pause = pause
self.is_cli = is_cli
self.error = None
self.script_iter = [None]
self.pause_timer = QTimer(app)
self.pause_timer.setSingleShot(True)
self.script_timer = QTimer(app)
def run(self):
ret = run_script(self.script, self.widget)
if isinstance(ret, Exception):
raise ret
self.script_iter = [iter(ret) if inspect.isgenerator(ret) else None]
if self.pause != 0:
self.script_timer.setInterval(self.pause * 1000)
# Zero-timeout timer runs script_runner() between Qt events
self.script_timer.timeout.connect(self, Qt.QueuedConnection)
QMetaObject.invokeMethod(self.script_timer, 'start', Qt.QueuedConnection)
def __call__(self):
app = get_application()
if not self.pause_timer.isActive():
try:
script_iter = self.script_iter[-1]
if script_iter is None:
if self.close_on_finish:
app.closeAllWindows()
app.exit()
return
# Run test script until the next 'yield'
try:
ret = next(script_iter)
except ValueError:
return
while ret is not None:
if inspect.isgenerator(ret):
self.script_iter.append(ret)
ret = None
elif isinstance(ret, six.integer_types) or isinstance(ret, float):
# Start non-blocking pause in seconds
self.pause_timer.start(int(ret * 1000))
ret = None
else:
ret = ret()
except StopIteration:
if len(self.script_iter) > 1:
self.script_iter.pop()
else:
self.script_iter = [None]
self.script_timer.stop()
if self.close_on_finish:
app.closeAllWindows()
app.exit(0)
except Exception as e:
self.script_iter = [None]
traceback.print_exc()
if self.close_on_finish:
app.exit(1)
self.error = e
示例7: _RequestsDownloadAPI
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
class _RequestsDownloadAPI(QObject):
"""Download API based on requests."""
_sig_download_finished = Signal(str, str)
_sig_download_progress = Signal(str, str, int, int)
def __init__(self, load_rc_func=None):
"""Download API based on requests."""
super(QObject, self).__init__()
self._conda_api = CondaAPI()
self._queue = deque()
self._threads = []
self._workers = []
self._timer = QTimer()
self._load_rc_func = load_rc_func
self._chunk_size = 1024
self._timer.setInterval(1000)
self._timer.timeout.connect(self._clean)
@property
def proxy_servers(self):
"""Return the proxy servers available from the conda rc config file."""
if self._load_rc_func is None:
return {}
else:
return self._load_rc_func().get('proxy_servers', {})
def _clean(self):
"""Check for inactive workers and remove their references."""
if self._workers:
for w in self._workers:
if w.is_finished():
self._workers.remove(w)
if self._threads:
for t in self._threads:
if t.isFinished():
self._threads.remove(t)
else:
self._timer.stop()
def _start(self):
"""Start the next threaded worker in the queue."""
if len(self._queue) == 1:
thread = self._queue.popleft()
thread.start()
self._timer.start()
def _create_worker(self, method, *args, **kwargs):
"""Create a new worker instance."""
thread = QThread()
worker = RequestsDownloadWorker(method, args, kwargs)
worker.moveToThread(thread)
worker.sig_finished.connect(self._start)
self._sig_download_finished.connect(worker.sig_download_finished)
self._sig_download_progress.connect(worker.sig_download_progress)
worker.sig_finished.connect(thread.quit)
thread.started.connect(worker.start)
self._queue.append(thread)
self._threads.append(thread)
self._workers.append(worker)
self._start()
return worker
def _download(self, url, path=None, force=False):
"""Callback for download."""
if path is None:
path = url.split('/')[-1]
# Make dir if non existent
folder = os.path.dirname(os.path.abspath(path))
if not os.path.isdir(folder):
os.makedirs(folder)
# Start actual download
try:
r = requests.get(url, stream=True, proxies=self.proxy_servers)
except Exception as error:
print('ERROR', 'here', error)
logger.error(str(error))
# Break if error found!
# self._sig_download_finished.emit(url, path)
# return path
total_size = int(r.headers.get('Content-Length', 0))
# Check if file exists
if os.path.isfile(path) and not force:
file_size = os.path.getsize(path)
# Check if existing file matches size of requested file
if file_size == total_size:
self._sig_download_finished.emit(url, path)
return path
# File not found or file size did not match. Download file.
progress_size = 0
with open(path, 'wb') as f:
#.........这里部分代码省略.........
示例8: ProcessWorker
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
class ProcessWorker(QObject):
"""
"""
sig_finished = Signal(object, object, object)
sig_partial = Signal(object, object, object)
def __init__(self, cmd_list, parse=False, pip=False, callback=None,
extra_kwargs={}):
super(ProcessWorker, self).__init__()
self._result = None
self._cmd_list = cmd_list
self._parse = parse
self._pip = pip
self._conda = not pip
self._callback = callback
self._fired = False
self._communicate_first = False
self._partial_stdout = None
self._extra_kwargs = extra_kwargs
self._timer = QTimer()
self._process = QProcess()
self._timer.setInterval(50)
self._timer.timeout.connect(self._communicate)
self._process.finished.connect(self._communicate)
self._process.readyReadStandardOutput.connect(self._partial)
def _partial(self):
raw_stdout = self._process.readAllStandardOutput()
stdout = handle_qbytearray(raw_stdout, _CondaAPI.UTF8)
json_stdout = stdout.replace('\n\x00', '')
try:
json_stdout = json.loads(json_stdout)
except Exception:
json_stdout = stdout
if self._partial_stdout is None:
self._partial_stdout = stdout
else:
self._partial_stdout += stdout
self.sig_partial.emit(self, json_stdout, None)
def _communicate(self):
"""
"""
if not self._communicate_first:
if self._process.state() == QProcess.NotRunning:
self.communicate()
elif self._fired:
self._timer.stop()
def communicate(self):
"""
"""
self._communicate_first = True
self._process.waitForFinished()
if self._partial_stdout is None:
raw_stdout = self._process.readAllStandardOutput()
stdout = handle_qbytearray(raw_stdout, _CondaAPI.UTF8)
else:
stdout = self._partial_stdout
raw_stderr = self._process.readAllStandardError()
stderr = handle_qbytearray(raw_stderr, _CondaAPI.UTF8)
result = [stdout.encode(_CondaAPI.UTF8), stderr.encode(_CondaAPI.UTF8)]
# FIXME: Why does anaconda client print to stderr???
if PY2:
stderr = stderr.decode()
if 'using anaconda cloud api site' not in stderr.lower():
if stderr.strip() and self._conda:
raise Exception('{0}:\n'
'STDERR:\n{1}\nEND'
''.format(' '.join(self._cmd_list),
stderr))
# elif stderr.strip() and self._pip:
# raise PipError(self._cmd_list)
else:
result[-1] = ''
if self._parse and stdout:
try:
result = json.loads(stdout), result[-1]
except ValueError as error:
result = stdout, error
if 'error' in result[0]:
error = '{0}: {1}'.format(" ".join(self._cmd_list),
result[0]['error'])
result = result[0], error
if self._callback:
result = self._callback(result[0], result[-1],
**self._extra_kwargs), result[-1]
#.........这里部分代码省略.........
示例9: AsyncClient
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
#.........这里部分代码省略.........
env.update(self.env)
for envItem in env:
envName, separator, envValue = envItem.partition('=')
processEnvironment.insert(envName, envValue)
self.process.setProcessEnvironment(processEnvironment)
# Start the process and wait for started.
self.process.start(self.executable, p_args)
self.process.finished.connect(self._on_finished)
running = self.process.waitForStarted()
if not running:
raise IOError('Could not start %s' % self)
# Set up the socket notifer.
fid = self.socket.getsockopt(zmq.FD)
self.notifier = QSocketNotifier(fid, QSocketNotifier.Read, self)
self.notifier.activated.connect(self._on_msg_received)
def request(self, func_name, *args, **kwargs):
"""Send a request to the server.
The response will be a dictionary the 'request_id' and the
'func_name' as well as a 'result' field with the object returned by
the function call or or an 'error' field with a traceback.
"""
if not self.is_initialized:
return
request_id = uuid.uuid4().hex
request = dict(func_name=func_name,
args=args,
kwargs=kwargs,
request_id=request_id)
self._send(request)
return request_id
def close(self):
"""Cleanly close the connection to the server.
"""
self.closing = True
self.is_initialized = False
self.timer.stop()
self.notifier.activated.disconnect(self._on_msg_received)
self.notifier.setEnabled(False)
del self.notifier
self.request('server_quit')
self.process.waitForFinished(1000)
self.process.close()
self.context.destroy()
def _on_finished(self):
"""Handle a finished signal from the process.
"""
if self.closing:
return
if self.is_initialized:
debug_print('Restarting %s' % self.name)
debug_print(self.process.readAllStandardOutput())
debug_print(self.process.readAllStandardError())
self.is_initialized = False
self.notifier.setEnabled(False)
self.run()
else:
debug_print('Errored %s' % self.name)
debug_print(self.process.readAllStandardOutput())
debug_print(self.process.readAllStandardError())
self.errored.emit()
def _on_msg_received(self):
"""Handle a message trigger from the socket.
"""
self.notifier.setEnabled(False)
while 1:
try:
resp = self.socket.recv_pyobj(flags=zmq.NOBLOCK)
except zmq.ZMQError:
self.notifier.setEnabled(True)
return
if not self.is_initialized:
self.is_initialized = True
debug_print('Initialized %s' % self.name)
self.initialized.emit()
self.timer.start(HEARTBEAT)
continue
resp['name'] = self.name
self.received.emit(resp)
def _heartbeat(self):
"""Send a heartbeat to keep the server alive.
"""
self._send(dict(func_name='server_heartbeat'))
def _send(self, obj):
"""Send an object to the server.
"""
try:
self.socket.send_pyobj(obj)
except Exception as e:
debug_print(e)
self.is_initialized = False
self._on_finished()
示例10: Connection
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
#.........这里部分代码省略.........
try:
self.pv.put(value)
except pyca.caexc as e:
print("pyca error: {}".format(e))
@Slot(np.ndarray)
def put_waveform(self, value):
"""
Set a PV's waveform value in EPICS. This is a deprecated function kept
temporarily for compatibility with old code.
:param value: The waveform value we'd like to put to our PV.
:type value: np.ndarray
"""
self.put_value(value)
def scan_pv_cb(self, e=None):
"""
Call set_throttle once we have a value from the scan_pv. We need this
value inside set_throttle to decide if we can ignore the throttle
request (i.e. our pv updates more slowly than our throttle)
:param e: Error state. Should be None under normal circumstances.
"""
if e is None:
self.pv.wait_ready()
count = self.pv.count or 1
if count > 1:
max_data_rate = 1000000. # bytes/s
bytes = self.pv.value.itemsize # bytes
throttle = max_data_rate / (bytes * count) # Hz
if throttle < 120:
self.set_throttle(throttle)
@Slot(int)
@Slot(float)
def set_throttle(self, refresh_rate):
"""
Throttle our update rate. This is useful when the data is large (e.g.
image waveforms). Set to zero to disable throttling.
:param delay: frequency of pv updates
:type delay: float or int
"""
try:
scan = scan_list[self.scan_pv.value]
except:
scan = float("inf")
if 0 < refresh_rate < 1 / scan:
self.pv.monitor_stop()
self.throttle.setInterval(1000.0 / refresh_rate)
self.throttle.start()
else:
self.throttle.stop()
if not self.pv.ismonitored:
self.pv.monitor()
def add_listener(self, channel):
"""
Connect a channel's signals and slots with this object's signals and slots.
:param channel: The channel to connect.
:type channel: :class:`PyDMChannel`
"""
super(Connection, self).add_listener(channel)
# If we are adding a listener to an already existing PV, we need to
# manually send the signals indicating that the PV is connected, what
# the latest value is, etc.
if self.pv.isconnected and self.pv.isinitialized:
self.send_connection_state(conn=True)
self.monitor_cb()
self.update_enums()
self.send_ctrl_vars()
if channel.value_signal is not None:
try:
channel.value_signal[str].connect(self.put_value, Qt.QueuedConnection)
except KeyError:
pass
try:
channel.value_signal[int].connect(self.put_value, Qt.QueuedConnection)
except KeyError:
pass
try:
channel.value_signal[float].connect(self.put_value, Qt.QueuedConnection)
except KeyError:
pass
try:
channel.value_signal[np.ndarray].connect(self.put_value, Qt.QueuedConnection)
except KeyError:
pass
def close(self):
"""
Clean up.
"""
self.throttle.stop()
self.pv.monitor_stop()
self.pv.disconnect()
self.scan_pv.monitor_stop()
self.scan_pv.disconnect()
示例11: FindReplace
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
#.........这里部分代码省略.........
if multiline_replace_check and self.replace_widgets[0].isVisible() and \
len(to_text_string(self.editor.get_selected_text()).splitlines())>1:
return None
text = self.search_text.currentText()
if len(text) == 0:
self.search_text.lineEdit().setStyleSheet("")
if not self.is_code_editor:
# Clears the selection for WebEngine
self.editor.find_text('')
self.change_number_matches()
return None
else:
case = self.case_button.isChecked()
words = self.words_button.isChecked()
regexp = self.re_button.isChecked()
found = self.editor.find_text(text, changed, forward, case=case,
words=words, regexp=regexp)
stylesheet = self.STYLE[found]
tooltip = self.TOOLTIP[found]
if not found and regexp:
error_msg = regexp_error_msg(text)
if error_msg: # special styling for regexp errors
stylesheet = self.STYLE['regexp_error']
tooltip = self.TOOLTIP['regexp_error'] + ': ' + error_msg
self.search_text.lineEdit().setStyleSheet(stylesheet)
self.search_text.setToolTip(tooltip)
if self.is_code_editor and found:
block = self.editor.textCursor().block()
TextHelper(self.editor).unfold_if_colapsed(block)
if rehighlight or not self.editor.found_results:
self.highlight_timer.stop()
if start_highlight_timer:
self.highlight_timer.start()
else:
self.highlight_matches()
else:
self.clear_matches()
number_matches = self.editor.get_number_matches(text, case=case,
regexp=regexp)
if hasattr(self.editor, 'get_match_number'):
match_number = self.editor.get_match_number(text, case=case,
regexp=regexp)
else:
match_number = 0
self.change_number_matches(current_match=match_number,
total_matches=number_matches)
return found
@Slot()
def replace_find(self, focus_replace_text=False, replace_all=False):
"""Replace and find"""
if (self.editor is not None):
replace_text = to_text_string(self.replace_text.currentText())
search_text = to_text_string(self.search_text.currentText())
re_pattern = None
# Check regexp before proceeding
if self.re_button.isChecked():
try:
re_pattern = re.compile(search_text)
# Check if replace_text can be substituted in re_pattern
# Fixes issue #7177
示例12: MatplotlibDataViewer
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
#.........这里部分代码省略.........
self._monitor_computation = QTimer()
self._monitor_computation.setInterval(500)
self._monitor_computation.timeout.connect(self._update_computation)
def _update_computation(self, message=None):
# If we get a ComputationStartedMessage and the timer isn't currently
# active, then we start the timer but we then return straight away.
# This is to avoid showing the 'Computing' message straight away in the
# case of reasonably fast operations.
if isinstance(message, ComputationStartedMessage):
if not self._monitor_computation.isActive():
self._monitor_computation.start()
return
for layer_artist in self.layers:
if layer_artist.is_computing:
self.loading_rectangle.set_visible(True)
text = self.loading_text.get_text()
if text.count('.') > 2:
text = 'Computing'
else:
text += '.'
self.loading_text.set_text(text)
self.loading_text.set_visible(True)
self.redraw()
return
self.loading_rectangle.set_visible(False)
self.loading_text.set_visible(False)
self.redraw()
# If we get here, the computation has stopped so we can stop the timer
self._monitor_computation.stop()
def add_data(self, *args, **kwargs):
return super(MatplotlibDataViewer, self).add_data(*args, **kwargs)
def add_subset(self, *args, **kwargs):
return super(MatplotlibDataViewer, self).add_subset(*args, **kwargs)
def update_x_axislabel(self, *event):
self.axes.set_xlabel(self.state.x_axislabel,
weight=self.state.x_axislabel_weight,
size=self.state.x_axislabel_size)
self.redraw()
def update_y_axislabel(self, *event):
self.axes.set_ylabel(self.state.y_axislabel,
weight=self.state.y_axislabel_weight,
size=self.state.y_axislabel_size)
self.redraw()
def update_x_ticklabel(self, *event):
self.axes.tick_params(axis='x', labelsize=self.state.x_ticklabel_size)
self.axes.xaxis.get_offset_text().set_fontsize(self.state.x_ticklabel_size)
self.redraw()
def update_y_ticklabel(self, *event):
self.axes.tick_params(axis='y', labelsize=self.state.y_ticklabel_size)
self.axes.yaxis.get_offset_text().set_fontsize(self.state.y_ticklabel_size)
self.redraw()
def redraw(self):
self.figure.canvas.draw()
示例13: CondaDependenciesModel
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
class CondaDependenciesModel(QAbstractTableModel):
""" """
def __init__(self, parent, dic, packages_sizes=None):
super(CondaDependenciesModel, self).__init__(parent)
self._parent = parent
self._packages = dic
self._packages_sizes = packages_sizes
self._rows = []
self._bold_rows = []
self._timer = QTimer()
self._timer.timeout.connect(self._timer_update)
self._timer_dots = ['. ', '.. ', '...', ' ']
self._timer_counter = 0
if len(dic) == 0:
self._timer.start(650)
self._rows = [[_(u'Resolving dependencies '), u'', u'', u'']]
self._bold_rows.append(0)
else:
if 'actions' in dic:
dic = dic['actions']
titles = [_('Name'), _('Unlink'), _('Link'), _('Download')]
order = ['UNLINK', 'LINK', 'FETCH']
packages_dic = self._build_packages_table(dic)
total_size = packages_dic.pop('TOTAL##', '')
packages_order = sorted(list(packages_dic))
rows = [titles]
self._bold_rows.append(0)
for package in packages_order:
row = [package]
item = packages_dic[package]
for section in order:
row.append(item.get(section, u'-'))
rows.append(row)
if total_size:
rows.append([u'', u'', u'', u'TOTAL'])
rows.append([u'', u'', u'', total_size])
self._bold_rows.append(len(rows) - 2)
self._bold_rows.append(len(rows) - 1)
for row in rows:
self._rows.append(row)
def _timer_update(self):
"""Add some moving points to the dependency resolution text."""
self._timer_counter += 1
dot = self._timer_dots.pop(0)
self._timer_dots = self._timer_dots + [dot]
self._rows = [[_(u'Resolving dependencies') + dot, u'', u'', u'']]
index = self.createIndex(0, 0)
self.dataChanged.emit(index, index)
if self._timer_counter > 150:
self._timer.stop()
self._timer_counter = 0
def _build_packages_table(self, dic):
""" """
self._timer.stop()
sections = {'FETCH': None,
'EXTRACT': None,
'LINK': None,
'UNLINK': None}
packages = {}
for section in sections:
sections[section] = dic.get(section, ())
if sections[section]:
for item in sections[section]:
i = item.split(' ')[0]
name, version, build = split_canonical_name(i)
packages[name] = {}
for section in sections:
pkgs = sections[section]
for item in pkgs:
i = item.split(' ')[0]
name, version, build = split_canonical_name(i)
packages[name][section] = version
total = 0
for pkg in packages:
val = packages[pkg]
if u'FETCH' in val:
v = val['FETCH']
if pkg in self._packages_sizes:
size = self._packages_sizes[pkg].get(v, '-')
if size != '-':
total += size
size = human_bytes(size)
packages[pkg]['FETCH'] = size
packages['TOTAL##'] = human_bytes(total)
return packages
def flags(self, index):
"""Override Qt method"""
#.........这里部分代码省略.........
示例14: ProcessWorker
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
class ProcessWorker(QObject):
"""Process worker based on a QProcess for non blocking UI."""
sig_started = Signal(object)
sig_finished = Signal(object, object, object)
sig_partial = Signal(object, object, object)
def __init__(self, cmd_list, environ=None):
"""
Process worker based on a QProcess for non blocking UI.
Parameters
----------
cmd_list : list of str
Command line arguments to execute.
environ : dict
Process environment,
"""
super(ProcessWorker, self).__init__()
self._result = None
self._cmd_list = cmd_list
self._fired = False
self._communicate_first = False
self._partial_stdout = None
self._started = False
self._timer = QTimer()
self._process = QProcess()
self._set_environment(environ)
self._timer.setInterval(150)
self._timer.timeout.connect(self._communicate)
self._process.readyReadStandardOutput.connect(self._partial)
def _get_encoding(self):
"""Return the encoding/codepage to use."""
enco = 'utf-8'
# Currently only cp1252 is allowed?
if WIN:
import ctypes
codepage = to_text_string(ctypes.cdll.kernel32.GetACP())
# import locale
# locale.getpreferredencoding() # Differences?
enco = 'cp' + codepage
return enco
def _set_environment(self, environ):
"""Set the environment on the QProcess."""
if environ:
q_environ = self._process.processEnvironment()
for k, v in environ.items():
q_environ.insert(k, v)
self._process.setProcessEnvironment(q_environ)
def _partial(self):
"""Callback for partial output."""
raw_stdout = self._process.readAllStandardOutput()
stdout = handle_qbytearray(raw_stdout, self._get_encoding())
if self._partial_stdout is None:
self._partial_stdout = stdout
else:
self._partial_stdout += stdout
self.sig_partial.emit(self, stdout, None)
def _communicate(self):
"""Callback for communicate."""
if (not self._communicate_first and
self._process.state() == QProcess.NotRunning):
self.communicate()
elif self._fired:
self._timer.stop()
def communicate(self):
"""Retrieve information."""
self._communicate_first = True
self._process.waitForFinished()
enco = self._get_encoding()
if self._partial_stdout is None:
raw_stdout = self._process.readAllStandardOutput()
stdout = handle_qbytearray(raw_stdout, enco)
else:
stdout = self._partial_stdout
raw_stderr = self._process.readAllStandardError()
stderr = handle_qbytearray(raw_stderr, enco)
result = [stdout.encode(enco), stderr.encode(enco)]
if PY2:
stderr = stderr.decode()
result[-1] = ''
self._result = result
if not self._fired:
self.sig_finished.emit(self, result[0], result[-1])
#.........这里部分代码省略.........
示例15: WorkerManager
# 需要导入模块: from qtpy.QtCore import QTimer [as 别名]
# 或者: from qtpy.QtCore.QTimer import stop [as 别名]
class WorkerManager(QObject):
"""Spyder Worker Manager for Generic Workers."""
def __init__(self, max_threads=10):
"""Spyder Worker Manager for Generic Workers."""
super(QObject, self).__init__()
self._queue = deque()
self._queue_workers = deque()
self._threads = []
self._workers = []
self._timer = QTimer()
self._timer_worker_delete = QTimer()
self._running_threads = 0
self._max_threads = max_threads
# Keeps references to old workers
# Needed to avoud C++/python object errors
self._bag_collector = deque()
self._timer.setInterval(333)
self._timer.timeout.connect(self._start)
self._timer_worker_delete.setInterval(5000)
self._timer_worker_delete.timeout.connect(self._clean_workers)
def _clean_workers(self):
"""Delete periodically workers in workers bag."""
while self._bag_collector:
self._bag_collector.popleft()
self._timer_worker_delete.stop()
def _start(self, worker=None):
"""Start threads and check for inactive workers."""
if worker:
self._queue_workers.append(worker)
if self._queue_workers and self._running_threads < self._max_threads:
#print('Queue: {0} Running: {1} Workers: {2} '
# 'Threads: {3}'.format(len(self._queue_workers),
# self._running_threads,
# len(self._workers),
# len(self._threads)))
self._running_threads += 1
worker = self._queue_workers.popleft()
thread = QThread()
if isinstance(worker, PythonWorker):
worker.moveToThread(thread)
worker.sig_finished.connect(thread.quit)
thread.started.connect(worker._start)
thread.start()
elif isinstance(worker, ProcessWorker):
thread.quit()
worker._start()
self._threads.append(thread)
else:
self._timer.start()
if self._workers:
for w in self._workers:
if w.is_finished():
self._bag_collector.append(w)
self._workers.remove(w)
if self._threads:
for t in self._threads:
if t.isFinished():
self._threads.remove(t)
self._running_threads -= 1
if len(self._threads) == 0 and len(self._workers) == 0:
self._timer.stop()
self._timer_worker_delete.start()
def create_python_worker(self, func, *args, **kwargs):
"""Create a new python worker instance."""
worker = PythonWorker(func, args, kwargs)
self._create_worker(worker)
return worker
def create_process_worker(self, cmd_list, environ=None):
"""Create a new process worker instance."""
worker = ProcessWorker(cmd_list, environ=environ)
self._create_worker(worker)
return worker
def terminate_all(self):
"""Terminate all worker processes."""
for worker in self._workers:
worker.terminate()
# for thread in self._threads:
# try:
# thread.terminate()
# thread.wait()
# except Exception:
# pass
self._queue_workers = deque()
def _create_worker(self, worker):
"""Common worker setup."""
worker.sig_started.connect(self._start)
#.........这里部分代码省略.........