def __init__(self, buffer_size=5):
self.buffer_size = buffer_size
self.free_slots = QSemaphore(self.buffer_size)
self.used_slots = QSemaphore(0)
self.clear_buffer_add = QSemaphore(1)
self.clear_buffer_get = QSemaphore(1)
self.queue_mutex = QMutex()
self.queue = Queue(self.buffer_size)
def __init__(self, size):
# Save buffer size
self.bufferSize = size
# Create semaphores
self.freeSlots = QSemaphore(self.bufferSize)
self.usedSlots = QSemaphore(0)
self.clearBuffer_add = QSemaphore(1)
self.clearBuffer_get = QSemaphore(1)
# Create mutex
self.queueProtect = QMutex()
# Create queue
self.queue = Queue(self.bufferSize)
def __init__(self, parent=None):
super(MyWindow, self).__init__(parent)
self.init_Ui()
self.com = Common()
self.title = [
u"COUNT", u"CPU(%)", u"MEM(M)", u"FPS", u"Wifi下行(KB/S)",
u"Wifi上行(KB/S)", u"下载流量(MB)", u"上传流量(MB)", u"Wifi总流量(MB)",
u"移动网络下行(KB/S)", u"移动网络上行(KB/S)", u"下载流量(MB)", u"上传流量(MB)",
u"移动网络总流量(MB)", u"温度", "Drawcall", u"电量"
]
self.excel_path = "D:\PerfReport"
# self.create_excel()
self.getData = 0
BufferSize = 1 #同时并发的线程数
FpsS = QSemaphore(BufferSize) # cpu并发锁
CpuS = QSemaphore(0)
DrawcallS = QSemaphore(0)
NetS = QSemaphore(0)
MemS = QSemaphore(0)
TempS = QSemaphore(0)
BatteryS = QSemaphore(0)
TimeS = QSemaphore(0)
self.lock = {} #并发锁词典
self.lock['cpu'] = CpuS
self.lock['fps'] = FpsS
self.lock['drawcall'] = DrawcallS
self.lock['net'] = NetS
self.lock['mem'] = MemS
self.lock['temp'] = TempS
self.lock['battery'] = BatteryS
self.lock['time'] = TimeS
self.dw = Draw()
self.isCollect = 0
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.sem_for_timer = QSemaphore()
self.reader_Thread = QThread()
self.reader = ConsoleReader(self.sem_for_timer,
self.semaphore_start_reading)
self.reader.moveToThread(self.reader_Thread)
# self.timerThread = QThread()
# self.timer = Timer(self.sem_for_timer, self.reader_Thread)
# self.timer.moveToThread(self.timerThread)
self.writer_Thread = QThread()
self.writer = ConsoleWriter(self.semaphore_start_reading)
self.writer.moveToThread(self.writer_Thread)
self.thr_read = Thread(target=self.ff)
self.thr_write = Thread(target=self.ww)
# self.thr_timer = Thread(target=self.gg)
self.ui.startBt.clicked.connect(self.startProcess)
# self.writer.process_created.connect(self.pp)
# self.writer.process_created.connect(self.reader.set_pipe)
self.ui.sendBt.clicked.connect(self.addInput)
self.writer.value_entered.connect(self.semaphore_start_reading.release)
self.reader.readed.connect(self.addToConsole)
# self.timer.timeout.connect(self.newThread)
self.writer_Thread.start()
# self.timerThread.start()
self.reader_Thread.start()
def __init__(self, aw):
self.aw = aw
self.readRetries = 1
self.channels = 10 # maximal number of S7 channels
self.host = '127.0.0.1' # the TCP host
self.port = 102 # the TCP port
self.rack = 0 # 0,..,7
self.slot = 0 # 0,..,31
self.lastReadResult = 0 # this is set by eventaction following some custom button/slider S/ actions with "read" command
self.area = [0] * self.channels
self.db_nr = [1] * self.channels
self.start = [0] * self.channels
self.type = [
0
] * self.channels # type 0 => int, type 1 => float, type 2 => intFloat
# type 3 => Bool(0), type 4 => Bool(1), type 5 => Bool(2), type 6 => Bool(3), type 7 => Bool(4), type 8 => Bool(5), type 9 => Bool(6), type 10 => Bool(7)
self.mode = [
0
] * self.channels # temp mode is an int here, 0:__,1:C,2:F (this is different than other places)
self.div = [0] * self.channels
self.optimizer = True # if set, values of consecutive register addresses are requested in single requests
self.fetch_max_blocks = False # if set, the optimizer fetches only one sequence per area from the minimum to the maximum register ignoring gaps
# S7 areas associated to dicts associating S7 DB numbers to start registers in use
# for optimized read of full register segments with single requests
# this dict is re-computed on each connect() by a call to updateActiveRegisters()
# NOTE: for registers of type float (32bit = 2x16bit) also the succeeding register is registered here
self.activeRegisters = {}
# the readings cache that is filled by requesting sequences of values in blocks
self.readingsCache = {}
self.PID_area = 0
self.PID_db_nr = 0
self.PID_SV_register = 0
self.PID_p_register = 0
self.PID_i_register = 0
self.PID_d_register = 0
self.PID_ON_action = ""
self.PID_OFF_action = ""
self.PIDmultiplier = 0
self.SVtype = 0
self.SVmultiplier = 0
self.COMsemaphore = QSemaphore(1)
self.areas = [
0x81, # PE
0x82, # PA
0x83, # MK
0x1C, # CT
0x1D, # TM
0x84, # DB
]
self.plc = None
self.commError = False # True after a communication error was detected and not yet cleared by receiving proper data
self.libLoaded = False
def __init__(self, sendmessage, adderror, addserial, aw):
self.sendmessage = sendmessage # function to create an Artisan message to the user in the message line
self.adderror = adderror # signal an error to the user
self.addserial = addserial # add to serial log
self.aw = aw
# retries
self.readRetries = 1
#default initial settings. They are changed by settingsload() at initiation of program acording to the device chosen
self.comport = "COM5" #NOTE: this string should not be translated.
self.baudrate = 115200
self.bytesize = 8
self.parity = 'N'
self.stopbits = 1
self.timeout = 1.0
self.PID_slave_ID = 0
self.PID_SV_register = 0
self.PID_p_register = 0
self.PID_i_register = 0
self.PID_d_register = 0
self.PID_ON_action = ""
self.PID_OFF_action = ""
self.channels = 8
self.inputSlaves = [0] * self.channels
self.inputRegisters = [0] * self.channels
self.inputFloats = [False] * self.channels
self.inputBCDs = [False] * self.channels
self.inputCodes = [3] * self.channels
self.inputDivs = [0] * self.channels # 0: none, 1: 1/10, 2:1/100
self.inputModes = ["C"] * self.channels
self.optimizer = True # if set, values of consecutive register addresses are requested in single requests
# MODBUS functions associated to dicts associating MODBUS slave ids to registers in use
# for optimized read of full register segments with single requests
# this dict is re-computed on each connect() by a call to updateActiveRegisters()
# NOTE: for registers of type float and BCD (32bit = 2x16bit) also the succeeding register is registered here
self.activeRegisters = {}
# the readings cache that is filled by requesting sequences of values in blocks
self.readingsCache = {}
self.SVmultiplier = 0
self.PIDmultiplier = 0
self.byteorderLittle = False
self.wordorderLittle = True
self.master = None
self.COMsemaphore = QSemaphore(1)
self.host = '127.0.0.1' # the TCP/UDP host
self.port = 502 # the TCP/UDP port
self.type = 0
# type =
# 0: Serial RTU
# 1: Serial ASCII
# 2: Serial Binary
# 3: TCP
# 4: UDP
self.lastReadResult = 0 # this is set by eventaction following some custom button/slider Modbus actions with "read" command
self.commError = False # True after a communication error was detected and not yet cleared by receiving proper data
def __init__(self, self_id, message_manager, election_time=5):
super().__init__()
self.id = self_id
self.message_manager = message_manager
self.semaphore = QSemaphore(1)
self.self_elected = True
self.election_timer = election_time
self.message_manager.signal_candidate_found.connect(
self.candidate_found)
def read(self, *data):
id = self.__getRandomId()
sem = QSemaphore(1)
sem.acquire()
self.queue.put({'type': 'read', 'data': list(data), 'id': id, 'sem': sem})
# wait for release the semaphore
sem.acquire()
state = self.ids[id]
del self.ids[id]
return state
class Window(QMainWindow):
semaphore = QSemaphore()
input_sended = pyqtSignal()
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.input = None
# self.thr = Thread().
self.timer = QTimer()
self.reader_Thread = QThread()
self.reader = ConsoleReader(self.semaphore, self.timer)
self.reader.moveToThread(self.reader_Thread)
self.writer_Thread = QThread()
self.writer = ConsoleWriter(self.semaphore)
self.writer.moveToThread(self.writer_Thread)
self.ui.startBt.clicked.connect(self.startProcess)
self.writer.process_created.connect(self.pp)
# self.writer.process_created.connect(self.reader.set_pipe)
self.reader.readed.connect(self.addToConsole)
self.ui.sendBt.clicked.connect(self.addInput)
# self.timer.timeout.connect(self.ii)
# self.timer.timeout.connect(self.timer.stop)
self.reader_Thread.start()
self.writer_Thread.start()
def ii(self):
print('stopped')
# self.reader_Thread.terminate()
self.reader.thread().wait()
def pp(self, process):
self.reader.set_pipe(process)
def addToConsole(self, output):
self.ui.outputText.append(output)
def startProcess(self):
path = self.ui.comandLine.text()
if '\\' in path:
path = path.replace('\\', '/')
# print(path)
self.writer.createProcess(path)
self.reader.run()
def addInput(self):
input = self.ui.inputText.text()
self.writer.write(input)
self.ui.outputText.append('>'+input)
def establishSqliteConnection(self, dbFileName: str):
self.name = dbFileName
self.dbsemaphore = QSemaphore(
1) # to control concurrent write access to db
self.engine = create_engine(
'sqlite:///{dbFileName}'.format(dbFileName=dbFileName))
self.session = scoped_session(sessionmaker())
self.session.configure(bind=self.engine, autoflush=False)
self.metadata = Base.metadata
self.metadata.create_all(self.engine)
self.metadata.echo = True
self.metadata.bind = self.engine
def connect(self, dbfilename):
self.name = dbfilename
self.dbsemaphore = QSemaphore(
1) # to control concurrent write access to db
self.engine = create_engine('sqlite:///' + dbfilename,
connect_args={"check_same_thread": False})
self.session = scoped_session(sessionmaker())
self.session.configure(bind=self.engine, autoflush=False)
self.metadata = Base.metadata
self.metadata.create_all(self.engine)
self.metadata.echo = True
self.metadata.bind = self.engine
def __init__(self):
# a dictionary associating all physical attached Phidget channels
# to their availablility state:
# True: available for attach to a software channel
# False: occupied and connected to a software channel
# access to this dict is protected by the managersemaphore and
# should happen only via the methods addChannel and deleteChannel
self.attachedPhidgetChannels = {}
self.managersemaphore = QSemaphore(1)
self.manager = Manager()
self.manager.setOnAttachHandler(self.attachHandler)
self.manager.setOnDetachHandler(self.detachHandler)
self.manager.open()
def delay_method_call(self, *args, **kwargs):
if self.thread() != QThread.currentThread():
semaphore = QSemaphore()
else:
semaphore = None
event = QueuedCallEvent(method, (self, ) + args, kwargs, semaphore)
QCoreApplication.postEvent(self, event)
if semaphore is None:
QCoreApplication.sendPostedEvents()
else:
# Wait until the other thread's event loop processes the event
semaphore.acquire()
return event.result()
def openDB(self, dbfilename):
try:
self.name = dbfilename
self.dbsemaphore = QSemaphore(1) # to control concurrent write access to db
self.engine = create_engine('sqlite:///{dbFileName}'.format(dbFileName = dbfilename)) #, poolclass=SingletonThreadPool)
self.session = scoped_session(sessionmaker())
self.session.configure(bind = self.engine, autoflush=False)
self.metadata = Base.metadata
self.metadata.create_all(self.engine)
self.metadata.echo = True
self.metadata.bind = self.engine
except:
log.info('Could not open database file. Is the file corrupted?')
def _play(self):
#Input values
start = float(self.startInput.text())
stop = float(self.stopInput.text())
#If state is PAUSE skip these steps
if self.state != "PAUSE":
self.timePosition = start
#Iterator preparation
sampleRate = self.eegSettings["sampleRate"]
iterStep = int(round(sampleRate * self.simDelay))
iterStart = int(start * sampleRate)
iterStop = int(stop * sampleRate)
#simDelay correction for int aproximation
self.simDelay = iterStep / sampleRate
self.iterator = iter(self.helper[iterStart:iterStop:iterStep])
#Next iteration to test if values are correct
try:
next(self.iterator)
except StopIteration:
QtWidgets.QMessageBox.warning(
self, "Error", "The start and stop points are too close",
QtWidgets.QMessageBox.Ok)
return
#Initialize animations of windows
for window in self.windowList:
window.initAnimation(start)
#Init semaphore and loopTrigger
self.semaphore = QSemaphore(0)
loop = LoopTrigger(self.semaphore, minDelay=self.rtDelay)
self.loop = loop
#Connect signals
loop.sigUpdate.connect(self.__updateFields)
loop.sigUpdate.connect(self.__playAnimation)
self.stopSignal.connect(loop.stop)
#Init thread
self.loopThread = QThread()
loop.moveToThread(self.loopThread)
self.loopThread.started.connect(loop.loop)
self.loopThread.start()
#Set new state
self.__setState("PLAY")
def __init__(self, dbfilename):
try:
self.name = dbfilename
self.dbsemaphore = QSemaphore(1) # to control concurrent write access to db
self.engine = create_engine('sqlite:///{dbFileName}'.format(dbFileName = dbfilename)) #, poolclass=SingletonThreadPool)
self.session = scoped_session(sessionmaker())
self.session.configure(bind = self.engine, autoflush=False)
self.metadata = Base.metadata
self.metadata.create_all(self.engine)
self.metadata.echo = True
self.metadata.bind = self.engine
except Exception as e:
log.info('Could not create database. Please try again.')
log.info(e)
def __init__(self, sendmessage, adderror, addserial):
self.sendmessage = sendmessage # function to create an Artisan message to the user in the message line
self.adderror = adderror # signal an error to the user
self.addserial = addserial # add to serial log
self.readRetries = 1
self.channels = 8 # maximal number of S7 channels
self.host = '127.0.0.1' # the TCP host
self.port = 102 # the TCP port
self.rack = 0 # 0,..,7
self.slot = 0 # 0,..,31
self.lastReadResult = 0 # this is set by eventaction following some custom button/slider S/ actions with "read" command
self.area = [0] * self.channels
self.db_nr = [1] * self.channels
self.start = [0] * self.channels
self.type = [0] * self.channels
self.mode = [
0
] * self.channels # temp mode is an int here, 0:__,1:C,2:F (this is different than other places)
self.div = [0] * self.channels
self.PID_area = 0
self.PID_db_nr = 0
self.PID_SV_register = 0
self.PID_p_register = 0
self.PID_i_register = 0
self.PID_d_register = 0
self.PID_ON_action = ""
self.PID_OFF_action = ""
self.SVmultiplier = 0
self.PIDmultiplier = 0
self.COMsemaphore = QSemaphore(1)
self.areas = [
0x81, # PE
0x82, # PA
0x83, # MK
0x1C, # CT
0x1D, # TM
0x84, # DB
]
self.plc = None
self.commError = False # True after a communication error was detected and not yet cleared by receiving proper data
class Window(QtWidgets.QMainWindow):
#семафор для работы потока
sem = QSemaphore()
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
#создаем и привязываем свою модель к представлению
self.model = TableModel()
self.ui.tableView.setModel(self.model)
self.ui.tableView.resizeColumnsToContents()
# создаем и устанавливаем в представление в столбец 1 делегат для выпадающего списка
self.delegate = DelegateComboBox(self.ui.tableView, 1)
self.ui.tableView.setEditTriggers(
QtWidgets.QAbstractItemView.DoubleClicked
| QtWidgets.QAbstractItemView.CurrentChanged
| QtWidgets.QAbstractItemView.SelectedClicked)
self.ui.tableView.setItemDelegateForColumn(1, self.delegate)
#обработка сигнала от кнопки Random
self.ui.btRandomNumbers.clicked.connect(self.autoFillTable)
#обработка сигнала от кнопки Resize
self.ui.btResizeTable.clicked.connect(self.resizeTableView)
#обработка выбора столбцов в таблице
#self.ui.tableView.model().dataChanged.connect(self.currentChangedInTableView)
#self.ui.tableView.model().dataChanged.connect(self.plotFromSelectedColumn)
#добавляем действия в меню для загрузки данных из файла
#HDF
self.openFileHdf = QtWidgets.QAction('Open from hdf', self)
self.openFileHdf.setStatusTip('Open file')
self.ui.menuHdf.addAction(self.openFileHdf)
#TXT
self.openFileTxt = QtWidgets.QAction('Open from txt', self)
self.openFileTxt.setStatusTip('Open file')
self.ui.menuTxt.addAction(self.openFileTxt)
#добавляем действия в менб для загрузки данных в файл
#HDF
self.saveFileHdf = QtWidgets.QAction('Save as hdf', self)
self.saveFileHdf.setStatusTip('Save to file')
self.ui.menuHdf.addAction(self.saveFileHdf)
#TXT
self.saveFileTxt = QtWidgets.QAction('Save as txt', self)
self.saveFileTxt.setStatusTip('Save to file')
self.ui.menuTxt.addAction(self.saveFileTxt)
#добавляем обработчики событий
self.openFileHdf.triggered.connect(self.loadData)
self.openFileTxt.triggered.connect(self.loadData)
self.saveFileHdf.triggered.connect(self.saveData)
self.saveFileTxt.triggered.connect(self.saveData)
#создаем timer с инетрвалом 1с чтобы он вызывал функцию рисования графика через некоторое время после выбора столбцов
#так как у меня основной поток не вовремя вызывает обработчик сигнала (данные о выборе не успевают обновлятся)
self.t = QtCore.QTimer(self)
self.t.timeout.connect(self.plotFromSelectedColumn)
self.t.start(1000)
# создаем поток с интервалом 1с чтобы он вызывал функцию рисования графика через некоторое время после выбора столбцов
# self.t = ClockThread(1, self.sem)
# self.t.timeout.connect(self.plotFromSelectedColumn)
# self.t.start()
#вызывается при измении размеров окна
def resizeEvent(self, a0: QtGui.QResizeEvent):
winHeight = self.height()
winWidth = self.width()
#изменяем размеры таблицы-представления
self.ui.tableView.resize(winWidth - 200, int(winHeight * 0.6))
#изменяем размеры виджета-графика
self.ui.graphWidget.setGeometry(0,
int(winHeight * 0.6) + 3, winWidth,
int(winHeight * 0.4) - 25)
#изменяем положение кнопок и надписей
self.ui.groupBox.setGeometry(
QRect(winWidth - 200, 0, 200, self.ui.tableView.height()))
#вызывается при нажатии на кнопку автозаполнения
def autoFillTable(self):
self.ui.tableView.model().autoFill()
#вызывается при нажатии на кнопку измения размера таблицы
def resizeTableView(self):
#вызываем у модели метод изменения ее размеров
self.ui.tableView.model().resize(int(self.ui.spBoxRows.text()),
int(self.ui.spBoxColumns.text()))
#вызывается при изменении выделения в представлении
#для разблокировки потока
def currentChangedInTableView(self):
#разблокировываем поток
self.sem.release()
#метод для рисования графика
def plotFromSelectedColumn(self):
#очищаем холст
self.ui.graphWidget.clear()
columns = set()
for a in self.ui.tableView.selectedIndexes():
columns.add(a.column())
#если выделено 2 столбца
if len(columns) == 2:
#получаем значения из модели
values = zip(self.ui.tableView.model().columnValues(columns.pop()),
self.ui.tableView.model().columnValues(columns.pop()))
#сортируем
x, y = list(zip(*sorted(values)))
#отрисовываем график
self.ui.graphWidget.plot(x, y)
#вызывается при нажатии на кнопку сохранения
def saveData(self):
try:
if self.sender().text() == 'Save as txt':
#получаем путь к файлу
fname, _ = QtWidgets.QFileDialog.getSaveFileName(
self, 'Save file', '/data.txt',
'Текстовые документы (*.txt)')
#передаем название файла модели
self.ui.tableView.model().saveAsTxt(fname)
else:
# получаем путь к файлу
fname, _ = QtWidgets.QFileDialog.getSaveFileName(
self, 'Save file', '/data.hdf5', 'HDF (*.hdf5)')
# передаем название файла модели
self.ui.tableView.model().saveAsHdf(fname)
except Exception:
QtWidgets.QMessageBox.about(self, ' ', 'Error')
#вызывается при нажатии на кнопку загрузки
def loadData(self):
try:
if self.sender().text() == 'Open from txt':
# получаем путь к файлу
fname, _ = QtWidgets.QFileDialog.getOpenFileName(
self, 'Open file', '/data.txt',
'Текстовые документы (*.txt)')
# передаем название файла модели
self.ui.tableView.model().loadFromTxt(fname)
else:
# получаем путь к файлу
fname, _ = QtWidgets.QFileDialog.getOpenFileName(
self, 'Open file', '/data.hdf5', 'HDF (*.hdf5)')
# передаем название файла модели
self.ui.tableView.model().loadFromHdf(fname)
self.ui.tableView.resizeColumnsToContents()
except Exception:
QtWidgets.QMessageBox.about(self, ' ', 'Error')
def __init__(self, sendmessage, adderror, addserial):
self.sendmessage = sendmessage # function to create an Artisan message to the user in the message line
self.adderror = adderror # signal an error to the user
self.addserial = addserial # add to serial log
# retries
self.readRetries = 1
#default initial settings. They are changed by settingsload() at initiation of program acording to the device chosen
self.comport = "COM5" #NOTE: this string should not be translated.
self.baudrate = 115200
self.bytesize = 8
self.parity = 'N'
self.stopbits = 1
self.timeout = 1.0
self.PID_slave_ID = 0
self.PID_SV_register = 0
self.PID_p_register = 0
self.PID_i_register = 0
self.PID_d_register = 0
self.PID_ON_action = ""
self.PID_OFF_action = ""
self.input1slave = 0
self.input1register = 0
self.input1float = False
self.input1bcd = False
self.input1code = 3
self.input1div = 0 # 0: none, 1: 1/10, 2:1/100
self.input1mode = "C"
self.input2slave = 0
self.input2register = 0
self.input2float = False
self.input2bcd = False
self.input2code = 3
self.input2div = 0
self.input2mode = "C"
self.input3slave = 0
self.input3register = 0
self.input3float = False
self.input3bcd = False
self.input3code = 3
self.input3div = 0
self.input3mode = "C"
self.input4slave = 0
self.input4register = 0
self.input4float = False
self.input4bcd = False
self.input4code = 3
self.input4div = 0
self.input4mode = "C"
self.input5slave = 0
self.input5register = 0
self.input5float = False
self.input5bcd = False
self.input5code = 3
self.input5div = 0
self.input5mode = "C"
self.input6slave = 0
self.input6register = 0
self.input6float = False
self.input6bcd = False
self.input6code = 3
self.input6div = 0
self.input6mode = "C"
self.SVmultiplier = 0
self.PIDmultiplier = 0
self.byteorderLittle = False
self.wordorderLittle = True
self.master = None
self.COMsemaphore = QSemaphore(1)
self.host = '127.0.0.1' # the TCP/UDP host
self.port = 502 # the TCP/UDP port
self.type = 0
# type =
# 0: Serial RTU
# 1: Serial ASCII
# 2: Serial Binary
# 3: TCP
# 4: UDP
self.lastReadResult = 0 # this is set by eventaction following some custom button/slider Modbus actions with "read" command
self.commError = False # True after a communication error was detected and not yet cleared by receiving proper data
# provided for educational purposes and is distributed in the hope that
# it will be useful, but WITHOUT ANY WARRANTY; without even the implied
# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
# the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import shelve
from pathlib import Path
from PyQt5.QtCore import QSemaphore
from plus import config, util
register_semaphore = QSemaphore(1)
uuid_cache_path = util.getDirectory(config.uuid_cache)
# register the path for the given uuid, assuming it points to the .alog profile containing that uuid
def addPath(uuid,path):
try:
config.logger.debug("register:setPath(" + str(uuid) + "," + str(path) + ")")
register_semaphore.acquire(1)
with shelve.open(uuid_cache_path) as db:
db[uuid] = path
except Exception as e:
config.logger.error("roast: Exception in addPath() %s",e)
finally:
class Window(QMainWindow):
semaphore_start_reading = QSemaphore()
input_sended = pyqtSignal()
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.sem_for_timer = QSemaphore()
self.reader_Thread = QThread()
self.reader = ConsoleReader(self.sem_for_timer,
self.semaphore_start_reading)
self.reader.moveToThread(self.reader_Thread)
# self.timerThread = QThread()
# self.timer = Timer(self.sem_for_timer, self.reader_Thread)
# self.timer.moveToThread(self.timerThread)
self.writer_Thread = QThread()
self.writer = ConsoleWriter(self.semaphore_start_reading)
self.writer.moveToThread(self.writer_Thread)
self.thr_read = Thread(target=self.ff)
self.thr_write = Thread(target=self.ww)
# self.thr_timer = Thread(target=self.gg)
self.ui.startBt.clicked.connect(self.startProcess)
# self.writer.process_created.connect(self.pp)
# self.writer.process_created.connect(self.reader.set_pipe)
self.ui.sendBt.clicked.connect(self.addInput)
self.writer.value_entered.connect(self.semaphore_start_reading.release)
self.reader.readed.connect(self.addToConsole)
# self.timer.timeout.connect(self.newThread)
self.writer_Thread.start()
# self.timerThread.start()
self.reader_Thread.start()
# def newThread(self):
# self.reader_Thread = QThread()
# self.reader = ConsoleReader(self.sem_for_timer, self.semaphore_start_reading)
# self.reader.moveToThread(self.reader_Thread)
#
# self.reader.set_pipe(self.writer.proc)
# self.reader.readed.connect(self.addToConsole)
# self.timer.set_readerThread(self.reader_Thread)
#
# self.reader_Thread.start()
# print('new thread')
# self.semaphore_start_reading.release()
# self.thr_read.run()
# self.thr_timer.run()
def addToConsole(self, output):
self.ui.outputText.append(output)
def startProcess(self):
path = self.ui.comandLine.text()
self.path = path.replace('\\', '/')
# print(path)
# self.writer.createProcess(path)
self.thr_write.start()
self.thr_read.start()
# self.thr_timer.start()
def addInput(self):
print('x')
input = self.ui.inputText.text()
print('y')
self.ui.outputText.append('>' + input)
self.writer.write(input)
def ff(self):
# self.sem = QSemaphore()
# self.timerThread = QThread()
# self.timer = Timer(self.sem)
# self.timer.moveToThread(self.timerThread)
# # self.timer.timeout.connect(self.ii)
# self.timerThread.start()
# reader_Thread = QThread()
# self.reader = ConsoleReader(self.semaphore)
# self.reader.moveToThread(reader_Thread)
#
# self.reader.readed.connect(self.addToConsole)
# reader_Thread.start()
# self.semaphore.acquire()
# self.reader.set_pipe(self.writer.proc)
# self.timer.start()
print('start read')
self.reader.run()
def ww(self):
print('start process')
print(self.path)
self.writer.createProcess(self.path)
self.reader.set_pipe(self.writer.proc)
__author__ = 'Administrator'
from PyQt5.QtCore import (QThread,pyqtSignal,QSemaphore,QUrl)
from PyQt5.QtNetwork import (QNetworkAccessManager,QNetworkRequest)
import requests
import xxtea
import time
import json
import random
mutex=QSemaphore(20)
class SearchThread(QThread):
domain = 'kyfw.12306.cn' #请求域名（真实连接地址）
host='kyfw.12306.cn' #请求的域名（host）
http = requests.session()
stopSignal=False
threadId=1
leftTicketUrl="leftTicket/query"
requests.packages.urllib3.disable_warnings()
searchThreadCallback= pyqtSignal(list)
def __init__(self,from_station,to_station,train_date,threadId,leftTicketUrl,interval=2,domain=''):
super(SearchThread,self).__init__()
if domain!='':
self.domain=domain
self.threadId=threadId
self.from_station=from_station
self.to_station=to_station
self.train_date=train_date
class Window(QMainWindow):
# семафор для работы потока
sem = QSemaphore()
sem_forBuffer = QSemaphore()
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# буфер для отправленных, но еще не обработанных сообщений
self.buffer = queue.Queue()
# потоки для обработки информации
self.sentThread = QThread()
self.sentObj = Producer(self.sem, self.buffer)
self.sentObj.moveToThread(self.sentThread)
self.n = 1
self.getThreadsPool = [QThread()]
self.getObjs = [Consumer(self.sem, self.sem_forBuffer, 1, self.buffer)]
self.getObjs[0].moveToThread(self.getThreadsPool[0])
self.ui.sendBt.clicked.connect(self.sentObj.run)
self.ui.sendBt.clicked.connect(self.check)
self.sentObj.message_sented.connect(self.getObjs[0].run)
self.sentObj.message_sented.connect(self.addSendedMessage)
self.getObjs[0].message_getted.connect(self.addGettedMessage)
self.ui.okBt.clicked.connect(self.change_threadNumber)
self.sem_forBuffer.release()
self.sentThread.start()
self.getThreadsPool[0].start()
def check(self):
print('check', self.sem_forBuffer.available())
def change_threadNumber(self):
n_new = self.ui.threadNumberSBox.value()
if self.n < n_new:
print(list(range(self.n, n_new)))
for i in range(self.n, n_new):
self.getThreadsPool.append(QThread())
self.getObjs.append(Consumer(self.sem, self.sem_forBuffer, i+1, self.buffer))
self.getObjs[i].moveToThread(self.getThreadsPool[i])
self.sentObj.message_sented.connect(self.getObjs[i].run)
self.getObjs[i].message_getted.connect(self.addGettedMessage)
self.getThreadsPool[i].start()
elif self.n > n_new:
for i in range(n_new, self.n):
self.getThreadsPool[i].terminate()
self.getThreadsPool[i].wait()
self.getThreadsPool = self.getThreadsPool[:n_new]
self.getObjs = self.getObjs[:n_new]
self.n = n_new
def addSendedMessage(self, message):
self.ui.sendedText.append(message)
# print('1')
def addGettedMessage(self, message):
print('add', self.sem_forBuffer.available())
self.sem_forBuffer.acquire(1)
self.ui.gettedText.append(message)
self.sem_forBuffer.release(1)
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import shelve
import portalocker
from PyQt5.QtCore import QSemaphore
from plus import config, util
#### Account Cache
# holding all account ids associated to a (local) running number
# shared cache between the Artisan and the ArtisanViewer app
account_cache_semaphore = QSemaphore(1)
# shared resource between the Artisan and ArtisanViewer app protected by a file lock
account_cache_path = util.getDirectory(config.account_cache,share=True)
account_cache_lock_path = util.getDirectory(config.account_cache + "_lock",share=True)
# register the given account_id and assign it a fresh number if not yet registered
# returns the number associated to account_id or None on error
def setAccount(account_id):
try:
config.logger.debug("account:setAccount(" + str(account_id) + ")")
account_cache_semaphore.acquire(1)
with portalocker.Lock(account_cache_lock_path, timeout=1) as _:
with shelve.open(account_cache_path) as db:
if account_id in db:
return db[account_id]
import platform
if platform.system().startswith("Windows") or platform.system() == 'Darwin':
import keyring.backends.fail # @UnusedImport
import keyring.backends.OS_X # @UnusedImport
import keyring.backends.SecretService # @UnusedImport
import keyring.backends.Windows # @UnusedImport
import keyring # @Reimport # imported last to make py2app work
from plus import config, account, util
from artisanlib import __version__
from PyQt5.QtCore import QSemaphore
token_semaphore = QSemaphore(
1) # protects access to the session token which is manipluated only here
def getToken():
try:
token_semaphore.acquire(1)
return config.token
except:
return None
finally:
if token_semaphore.available() < 1:
token_semaphore.release(1)
def getNickname():
try:
# the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import json
import time
from PyQt5.QtWidgets import QApplication
from PyQt5.QtCore import QSemaphore, QTimer
from artisanlib.util import d as decode, encodeLocal
from plus import config, connection, util, controller
stock_semaphore = QSemaphore(
1) # protects access to the stock_cache file and the stock dict
stock_cache_path = util.getDirectory(config.stock_cache)
stock = None # holds the dict with the current stock data (coffees, blends,..)
###################
# stock cache update
#
# updates the stock cache
def update():
QTimer.singleShot(2, lambda: update_blocking())
import shelve
import portalocker
import requests
from PyQt5.QtCore import QSemaphore, QTimer
from PyQt5.QtWidgets import QApplication
from plus import config, util, connection, controller, roast
#### Sync Cache
# holding all roast UUIDs under sync with the server
# shared cache between the Artisan and the ArtisanViewer app
sync_cache_semaphore = QSemaphore(1)
# if lock is True, return the path of the corresponding lock file
def getSyncPath(lock=False):
if config.account_nr is None or config.account_nr == 0:
fn = config.sync_cache
else:
fn = config.sync_cache + str(config.account_nr)
if lock:
fn = fn + "_lock"
return util.getDirectory(fn, share=True)
# register the modified_at timestamp (EPOC as float with milliseoncds) for the given uuid, assuming it holds the last timepoint modifications were last synced with the server
def addSync(uuid, modified_at):
try:
import keyring.backends.macOS # @UnusedImport @UnresolvedImport
keyring.set_keyring(keyring.backends.macOS.Keyring())
except:
import keyring.backends.OS_X # @UnusedImport @UnresolvedImport
keyring.set_keyring(keyring.backends.OS_X.Keyring())
import keyring.backends.SecretService # @UnusedImport
import keyring.backends.Windows # @UnusedImport
import keyring # @Reimport # imported last to make py2app work
from PyQt5.QtWidgets import QApplication, QMessageBox
from PyQt5.QtCore import QSemaphore, QTimer, Qt
from plus import config, connection, stock, queue, sync, roast, util
connect_semaphore = QSemaphore(1)
def is_connected():
try:
connect_semaphore.acquire(1)
return config.connected
finally:
if connect_semaphore.available() < 1:
connect_semaphore.release(1)
# artisan.plus is on as soon as an account id has been established
# Note that artisan.plus might be on, while not being connected due to connectivity issues
def is_on():
aw = config.app_window
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
## $QT_END_LICENSE$
##
#############################################################################
import sys
import random
from PyQt5.QtCore import QCoreApplication, QSemaphore, QThread
DataSize = 100000
BufferSize = 8192
buffer = list(range(BufferSize))
freeBytes = QSemaphore(BufferSize)
usedBytes = QSemaphore()
class Producer(QThread):
def run(self):
for i in range(DataSize):
freeBytes.acquire()
buffer[i % BufferSize] = "ACGT"[random.randint(0, 3)]
usedBytes.release()
class Consumer(QThread):
def run(self):
for i in range(DataSize):
usedBytes.acquire()
def run_process_conformity(self, progress_bar, params=None):
results = []
nc = cpu_count() - 1
sem = QSemaphore(nc)
bar_sem = QSemaphore(1)
qDebug("CPU count " + str(nc + 1))
parameters = params
self.attached_progess_bar = progress_bar
th_list = []
n = len(self.case_event_model.cases)
progress_bar.setMaximum(n)
qDebug("Process Conformity -- Run")
for (case, eventSeq) in self.case_event_model.cases.items():
dummyCase = (case, eventSeq)
#qDebug("Start -- Case %s" % str(case))
th = ReplayThread(self.process_model, dummyCase, progress_bar,
bar_sem, results, sem, parameters)
th.updateProgessbarSignal.connect(self.update_progress_bar_slot)
th_list.append((th, case))
th.start()
sem.acquire()
qDebug("All threads Created")
for (th, case) in th_list:
if th and th.isFinished():
pass
else:
sem.acquire()
th.updateProgessbarSignal.disconnect(self.update_progress_bar_slot)
n = 0
nCase = CaseAttributeModel(name="Conformity Process Result")
i_itens = []
legend = ["ID"]
if bool(parameters["conformity"]):
legend.append(["Conformity"])
if bool(parameters["types"]):
legend.append(["NonConformity Type"])
if parameters["notes"] == "add":
legend.append(["Notes"])
for i in range(len(legend)):
i_itens.append(i)
nCase.add_legend(legend)
string = "Params:"
for key, value in parameters.items():
string += "\t" + str(key) + " : " + str(value) + "\n"
string += "==============Report===========\n"
for item in results:
liste = []
string += str(item[0]) + " : "
if parameters["conformity"]:
liste.append(item[1])
string += str(item[1]) + "\t"
if parameters["types"]:
if parameters["style"] == "int":
liste.append(item[2])
string += str(item[2]) + "\t"
else:
if item[2] == 0:
liste.append("Conform")
string += format("%110s" % "Conform")
elif item[2] == 1:
liste.append("Non Conform: Inexistent Activity")
string += format("%110s" %
"Non Conform: Inexistent Activity")
elif item[2] == 2:
liste.append("Non Conform: Inexistent Transition")
string += format("%110s" %
"Non Conform: Inexistent Transition")
elif item[2] == 3:
liste.append(
"Non Conform: Inexistent Activity and Inexistent Transition"
)
string += format(
"%110s" %
"Non Conform: Inexistent Activity and Inexistent Transition"
)
elif item[2] == 4:
liste.append(
"Non Conform: Transition with Innapropriate Duration"
)
string += format(
"%110s" %
"Non Conform: Transition with Innapropriate Duration"
)
elif item[2] == 5:
liste.append(
"Non Conform: Transition with Innapropriate Duration and Inexistent Activity"
)
string += format(
"%110s" %
"Non Conform: Transition with Innapropriate Duration and Inexistent Activity"
)
elif item[2] == 6:
liste.append(
"Non Conform: Transition with Innapropriate Duration and Inexistent Transition"
)
string += format(
"%110s" %
"Non Conform: Transition with Innapropriate Duration and Inexistent Transition"
)
elif item[2] == 7:
liste.append(
"Non Conform: Transition with Innapropriate Duration, Inexistent Activity and Inexistent Transition"
)
string += format(
"%110s" %
"Non Conform: Transition with Innapropriate Duration, Inexistent Activity and Inexistent Transition"
)
if parameters["notes"] == "add":
liste.append(str(item[3]))
if parameters["notes"] != "ignore":
string += str(item[3]) + "\t"
nCase.add_case(item[0], liste)
string += "\n"
if parameters["result_group"] == "merge":
self.case_attribute_model[0].merge(nCase, i_itens)
self.attached_progess_bar.setValue(0)
self.attached_progess_bar = None
self.signal_project_has_changed.emit()
self.signal_conformity_algorithm_finished.emit(string)