def start(self, path): """ Public slot to populate the data. @param path directory name to show change lists for (string) """ self.changeListsDict = {} self.cancelled = False self.filesLabel.setText(self.trUtf8("Files (relative to %1):").arg(path)) QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) QApplication.processEvents() locker = QMutexLocker(self.vcs.vcsExecutionMutex) try: entries = self.client.get_changelist(path, depth=pysvn.depth.infinity) for entry in entries: file = entry[0] changelist = entry[1] if changelist not in self.changeListsDict: self.changeListsDict[changelist] = [] filename = file.replace(path + os.sep, "") if filename not in self.changeListsDict[changelist]: self.changeListsDict[changelist].append(filename) except pysvn.ClientError as e: locker.unlock() self.__showError(e.args[0]) self.__finish()
def process_packet(self, feedline): feedline = str(feedline) self.status['parse_error'] = True packet = {} if not feedline.startswith("*"): if feedline.startswith("#"): self._finish_command_response() else: self._process_command_response(feedline) return parts = feedline[2:].rstrip().split(' ') for part in parts: pair = part.split('=') if len(pair) != 2: return packet[str(pair[0])] = str(pair[1]) locker = QMutexLocker(self.lock) try: self.status.update({ "rpm": int(packet['rpm']), "sync": True if packet['sync'] == "1" else False, "t0_count": int(packet['t0_count']), "map": float(packet['map']), "advance": float(packet['adv']), "dwell": int(packet['dwell_us']) }) except: return finally: locker.unlock() self.status['parse_error'] = False self.feed_update.emit()
def sync(self): # Update people from backend try: newpeople = self.backend.getPersonList() with QMutexLocker(self.mutex): self.badgeToId = {} for person in newpeople: if person.id in self.people: self.people[person.id].updateFrom(person) else: self.people[person.id] = person self.badgeToId[person.badge] = person.id except IOError as e: # Unlikely we'll be able to do anything else self.statusUpdate.emit("Could not contact server to synchronize: %s" % e) return # Download photos as necessary for person in newpeople: size = 0 if person.photo: try: size = os.stat(person.photo).st_size except OSError: pass if person.photoRemote and size != person.photoSize: self.statusUpdate.emit("Downloading %s" % person.photoRemote) try: self.backend.getBadgePhoto(person.photoRemote, person.photo) except IOError as e: self.statusUpdate.emit("Failed when downloading %s: %s" % (person.photo, e)) # Push saved time log to server with QMutexLocker(self.mutex): if self.timeLog: try: self.statusUpdate.emit("Pushing %d time records" % len(self.timeLog)) ok = self.backend.putTimeRecords(self.timeLog) except IOError as e: self.statsChanged.emit() self.statusUpdate.emit("Failed to push time records: %s" % e) return self.timeLog = [v for i, v in enumerate(self.timeLog) if i not in ok] self.statusUpdate.emit("Pushed %d time records" % len(ok)) else: self.statusUpdate.emit("Synchronization complete") self.statsChanged.emit()
def render(self): locker = QMutexLocker(self.mutex) if not self.isRunning() and not self.countThread.isRunning() and not self.populateThread.isRunning() and not self.maxOccThread.isRunning(): self.start(QThread.LowPriority) else: self.restart = True self.condition.wakeOne()
def log(self, level, msg): """ Logs the inputed message with the given level. :param level | <int> | logging level value msg | <unicode> :return <bool> success """ locker = QMutexLocker(self._mutex) if (not self.isLoggingEnabled(level)): return False if isinstance(msg, QtCore.QString): msg = unicode(msg.toUtf8(), "UTF-8") msg = self._blankCache + msg if msg.endswith('\n'): self._blankCache = '\n' msg = msg[:-1] else: self._blankCache = '' self.setCurrentMode(level) self.insertPlainText(msg) if not self.signalsBlocked(): self.messageLogged.emit(level, msg) self.scrollToEnd() return True
def save(self): with QMutexLocker(self.mutex): with open("DataStore.pickle", "wb") as f: pickler = pickle.Pickler(f) pickler.dump(self.people) pickler.dump(self.clockedIn) pickler.dump(self.timeLog)
def sorted_active_runnable(self, query, hwnds): with QMutexLocker(self.mutex): # update query and collect active ones self._refresh_tasks(hwnds, query) active_tasks = [self.tasks[h] for h in hwnds] # sort by last use if not query: return sorted(active_tasks, key=lambda t: t.usetime, reverse=True) titles = [task.fullname.lower() for task in active_tasks] def f(task, title): return task.query.distance_to(title) ds = [ f(task, title) * (10**len(query)) for task, title in zip(active_tasks, titles) ] best = ds[0] for i in itertools.takewhile(lambda i: ds[i] == best, range(len(ds))): ds[i] -= len(lcs(query, titles[i])) #return sorted(active_tasks, key=f) return [ task for i, task in sorted(enumerate(active_tasks), key=lambda i: ds[i[0]]) ]
def signOutAll(self): """Sign out all clocked in records.""" with QMutexLocker(self.mutex): while self.clockedIn: record = self.clockedIn.popitem()[1] record.signOut() self.timeLog.append(record) self.save() self.statsChanged.emit()
def handle_signout(self): record = self.sender() id = record.person.id print("handling %d signing out" % id) with QMutexLocker(self.mutex): record = self.clockedIn.pop(id, None) if record is not None: self.timeLog.append(record) self.statsChanged.emit()
def clearAll(self): """Clear all clocked in records. They will be saved in the time log but with no hours credit.""" with QMutexLocker(self.mutex): while self.clockedIn: record = self.clockedIn.popitem()[1] record.clear() self.timeLog.append(record) self.save() self.statsChanged.emit()
def __init__(self, parent=None): """ Constructor @param parent reference to the parent widget @type QWidget """ QDialog.__init__(self, parent) self.setupUi(self) self.sock = sserver(upMainSig=self.updateMainSignal, recSignal=self.fromSocketfuncSignal, readySignal=self.serverCreateSignal) self.SERVER_RUN = False self.host = 'localhost' self.port = 9876 self.mode = 'TCP' ##地图加载完成标志 self.LOAD_FINISH = False self.mutex = QMutex() self.log = log.logfile('log') self.orderDict = {} if self.log is not None: with QMutexLocker(self.mutex): self.log.write('enter-socketFuc-class-INIT-' + str(self)) self.updateMainSignal.connect(self.say_hi) self.fromSocketfuncSignal.connect(self.sockToYingyan) #try to make sub dialog constant self.YingyanDailog = YingyanFunc( updateMainSignal=self.updateMainSignal, recDataSignal=self.toYingyanFuncSignal, toPickSignal=self.toPickPointSignal, sendOrderSignal=self.sendOrderSignal) self.PickPointDialog = PickPointfunc( upsignal=self.fromPickPointSignal, downsignal=self.toPickPointSignal, updateMainSignal=self.updateMainSignal, sendOrderSignal=self.sendOrderSignal, toDebugWindowSingal=self.toDebugWindowSignal) #todo:发送到socket的信号统一为sendOrderSignal #self.fromPickPointSignal.connect(self.processPickData) self.sendOrderSignal.connect(self.SendOrder) #调试窗口 self.debugWindow = DebugWindow(self.toDebugWindowSignal) self.ReadConfigFromFile() #server成功建立 self.serverCreateSignal.connect(self.ServerCreated)
def say_hi(self, words): ##show in the info area in dialog if str(words) == 'Loading map done': self.LOAD_FINISH = True try: self.sock_show_tb.append(str(words)) except Exception as e: self.sock_show_tb.append('<ERROR: invalid input from client>') ##add log with QMutexLocker(self.mutex): self.log.write(str(words))
def load_search_result_t(self, dic_file_lines, cases_num): """ :param dic_file_lines: dictionary, key = file path, value = lines matched :param cases_num: int, the number of cases matched :return: void """ from PyQt4.QtCore import QMutexLocker, QMutex mutex = QMutex() lock = QMutexLocker(mutex) self.ui.statusbar.showMessage('Start loading results.') self.ui.treeWidget_search_result.clear() self.load_search_result(dic_file_lines, cases_num)
def process2(self, obj): """ This function stops the thread calling this object. """ print(">> process():", os.getpid(), QThread.currentThread(), QThread.currentThreadId()) self.stopWorking = False while not self.stopWorking: try: with QMutexLocker(self.mutex): self._process() except Exception as ex: print(ex) self.stopWorking = True self.do_something.emit(self.data) self.finished.emit()
def find_files_in_path(self): self.filenames = [] for path, dirs, files in os.walk(self.rootpath): with QMutexLocker(self.mutex): if self.stopped: return False for d in dirs[:]: dirname = os.path.join(path, d) if re.search(self.exclude, dirname + os.sep): dirs.remove(d) for f in files: filename = os.path.join(path, f) if re.search(self.exclude, filename): continue if re.search(self.include, filename): self.filenames.append(filename) return True
def find_files_in_hg_manifest(self): p = Popen(['hg', 'manifest'], stdout=PIPE, cwd=self.rootpath) self.filenames = [] hgroot = get_hg_root(self.rootpath) for path in p.stdout.read().splitlines(): with QMutexLocker(self.mutex): if self.stopped: return False dirname = osp.dirname(path) if re.search(self.exclude, dirname + os.sep): continue filename = osp.basename(path) if re.search(self.exclude, filename): continue if re.search(self.include, filename): self.filenames.append(osp.join(hgroot, path)) return True
def find_string_in_files(self): self.results = {} self.nb = 0 self.error_flag = False for fname in self.filenames: with QMutexLocker(self.mutex): if self.stopped: return try: for lineno, line in enumerate(open(fname)): for text, enc in self.texts: if self.text_re: found = re.search(text, line) if found is not None: break else: found = line.find(text) if found > -1: break try: line_dec = line.decode(enc) except UnicodeDecodeError: line_dec = line if self.text_re: for match in re.finditer(text, line): res = self.results.get(osp.abspath(fname), []) res.append((lineno+1, match.start(), line_dec)) self.results[osp.abspath(fname)] = res self.nb += 1 else: while found > -1: res = self.results.get(osp.abspath(fname), []) res.append((lineno+1, found, line_dec)) self.results[osp.abspath(fname)] = res for text, enc in self.texts: found = line.find(text, found+1) if found > -1: break self.nb += 1 except IOError, (_errno, _strerror): self.error_flag = _("permission denied errors were encountered") except re.error: self.error_flag = _("invalid regular expression")
def find_files_in_python_path(self): self.filenames = [] directories = [path for path in sys.path \ if not path.startswith(sys.prefix)] for path in directories: if not path: path = os.getcwdu() with QMutexLocker(self.mutex): if self.stopped: return False dirname = osp.dirname(path) if re.search(self.exclude, dirname + os.sep): continue filename = osp.dirname(path) if re.search(self.exclude, filename): continue if re.search(self.include, filename): self.filenames.append(path) return True
def process(self): """ This function is to be connected with a pyqtSignal object on another thread. """ # print(">> process():", os.getpid(), QThread.currentThread(), QThread.currentThreadId()) # self.stopWorking = False # while not self.stopWorking: st = time.time() try: with QMutexLocker(self.mutex): self._process() except Exception as ex: print(ex) # self.stopWorking = True self.do_something.emit(self.data) elapsed = time.time() - st print("Elapsed time of process:{0:.4f} sec.".format(elapsed)) # if elapsed < self.sleepInterval: # time.sleep(self.sleepInterval - elapsed) self.finished.emit()
def find_files_in_hg_manifest(self): p = Popen(['hg', 'manifest'], stdout=PIPE, cwd=self.rootpath, shell=True) hgroot = get_vcs_root(self.rootpath) self.pathlist = [hgroot] for path in p.stdout.read().splitlines(): with QMutexLocker(self.mutex): if self.stopped: return False dirname = osp.dirname(path) try: if re.search(self.exclude, dirname+os.sep): continue filename = osp.basename(path) if re.search(self.exclude, filename): continue if re.search(self.include, filename): self.filenames.append(osp.join(hgroot, path)) except re.error: self.error_flag = _("invalid regular expression") return False return True
def process(self): print(">> process():", os.getpid(), QThread.currentThread(), QThread.currentThreadId()) self.isInterrupted = False count = 0 while not self.isInterrupted: if count == 10: self.isInterrupted = True continue try: with QMutexLocker(self.mutex): self.addA() self.addOne() time.sleep(1) count += 1 except Exception as ex: print(ex) self.isInterrupted = True print("<< process():", os.getpid(), QThread.currentThread(), QThread.currentThreadId()) self.do_something.emit(self.data) self.finished.emit()
def find_string_in_files(self): self.results = {} self.nb = 0 self.error_flag = False for fname in self.filenames: with QMutexLocker(self.mutex): if self.stopped: return try: for lineno, line in enumerate(file(fname)): for text in self.texts: if self.text_re: found = re.search(text, line) if found is not None: break else: found = line.find(text) if found > -1: break if self.text_re: for match in re.finditer(text, line): res = self.results.get(osp.abspath(fname), []) res.append((lineno + 1, match.start(), line)) self.results[osp.abspath(fname)] = res self.nb += 1 else: while found > -1: res = self.results.get(osp.abspath(fname), []) res.append((lineno + 1, found, line)) self.results[osp.abspath(fname)] = res for text in self.texts: found = line.find(text, found + 1) if found > -1: break self.nb += 1 except IOError, (_errno, _strerror): self.error_flag = translate( "FindInFiles", "permission denied errors were encountered")
def __init__(self, parent=None, mutex=None, host='localhost', port=9876, mode='TCP', upMainSig=None, recSignal=None, readySignal=None): super(sserver, self).__init__(parent) self.mutex = mutex self.host = host self.port = port self.mode = mode self.sserver = None self.RUN_FLAG = True self.client = None self.updateMain = upMainSig self.recDataSignal = recSignal self.readySignal = readySignal with QMutexLocker(self.mutex): self.updateMain.emit('new socket server- ' + str(self))
def find_files_in_path(self, path): if self.pathlist is None: self.pathlist = [] self.pathlist.append(path) for path, dirs, files in os.walk(path): with QMutexLocker(self.mutex): if self.stopped: return False try: for d in dirs[:]: dirname = os.path.join(path, d) if re.search(self.exclude, dirname+os.sep): dirs.remove(d) for f in files: filename = os.path.join(path, f) if re.search(self.exclude, filename): continue if re.search(self.include, filename): self.filenames.append(filename) except re.error: self.error_flag = _("invalid regular expression") return False return True
def signInOut(self, badge): """Sign person in or out (based on their current state). Returns None if person was previously signed in, otherwise returns created TimeRecord.""" with QMutexLocker(self.mutex): id = self.badgeToId[badge] person = self.people[id] record = self.clockedIn.pop(id, None) if record is not None: # signing out record.signOut() self.timeLog.append(record) self.save() self.statsChanged.emit() return None else: # signing in record = TimeRecord(person) record.completed.connect(self.handle_signout) self.clockedIn[id] = record self.save() self.statsChanged.emit() return record
def load(self): # Load pickles or create fresh if no pickle file with QMutexLocker(self.mutex): try: with open("DataStore.pickle", "rb") as f: unpickler = pickle.Unpickler(f) self.people = unpickler.load() self.clockedIn = unpickler.load() self.timeLog = unpickler.load() self.statusUpdate.emit( "Loaded %d people (%d clocked in) and %d time records." % (len(self.people), len(self.clockedIn), len(self.timeLog))) for record in self.clockedIn.values(): record.completed.connect(self.handle_signout) for person in self.people.values(): self.badgeToId[person.badge] = person.id except (IOError, EOFError): self.people = {} self.timeLog = [] self.clockedIn = {} self.badgeToId = {} self.statsChanged.emit()
def run(self): # print(self.hello) # print (self.para) #get lock with QMutexLocker(self.GPSMutex): up_count = 0 del_count = 0 fail_count = 0 # fail_list = [] if len(self.points) != 0: for point in self.points: if self.set_point(long= point[0], lat=point[1]): if self.upload_one_point(): up_count += 1 else: fail_count += 1 # fail_list.append(point) else: del_count +=1 self.points = [] self.update_main( 'enter-func-GpsUploader-run: ' + str(up_count) + ' uploaded, ' + str(fail_count) + ' failed, ' + str( del_count) + ' deleted.')
def add_point(self, point_tuple): #get lock with QMutexLocker(self.GPSMutex): self.points.append(point_tuple)
def jobFinished(self): lock = QMutexLocker(self.parent.mutex) self.parent.shutterReplied = True
def getNumClockedIn(self): with QMutexLocker(self.mutex): return len(self.clockedIn)
def getNumTimeEntries(self): with QMutexLocker(self.mutex): return len(self.timeLog)
def getNumPeople(self): with QMutexLocker(self.mutex): return len(self.people)