def __init__(self, app):
super().__init__()
self.app = app
self.showMaximized()
self.image_service = ImageService()
self.storage_service = StorageService()
self.stacked_widget = QStackedWidget()
self.stacked_widget.showMaximized()
self.main_widget = MainWidget(self)
self.settings_widget = SettingsWidget(self, Settings())
self.pattern_widget = PatternWidget(self, Pattern())
self.stacked_widget.addWidget(self.main_widget)
self.stacked_widget.addWidget(self.pattern_widget)
self.stacked_widget.addWidget(self.settings_widget)
self.setCentralWidget(self.stacked_widget)
self.selected_pattern_name = None
self.selected_settings_name = None
self.pattern = None
self.settings = None
self._create_actions()
self._set_menu_bar()
self._set_tool_bar()
self.errors_color = QColor(255, 0, 0)
def notify(ch, method, pros, data):
body = json.loads(data.decode("utf-8"))
group_id = body.get("group_id")
user_id = body.get("user")
notification_platform_name = body.get("provider")
if not notification_platform_name:
return None
storage_service = StorageService()
users_phones = storage_service.get_users(group_id=group_id,
user_id=user_id)
platform_instance = PlatformFactory.platform(
platform_name=notification_platform_name)
users = platform_instance.build_platform_users_object(
users_phones_list=users_phones)
body.update({"users": users})
return platform_instance.notify(notification_payload=body)
class StorageServiceTest(unittest.TestCase):
def setUp(self):
self.storage_service = StorageService()
self.pattern_name = 'test_pattern'
self.pattern = self.create_pattern(self.pattern_name)
self.settings_name = 'test_settings'
self.settings = Settings(self.settings_name)
def create_pattern(self, pattern_name):
bin_image = np.random.randint(2, size=(20, 10))
bin_image[bin_image == 1] = 255
keypoints = [
cv2.KeyPoint(5, 5, 2, -1, 0, 0, -1),
cv2.KeyPoint(2, 2, 1, -1, 1, 1, -1)
]
descriptors = np.random.randint(256, size=(len(keypoints), 32))
return Pattern(pattern_name, bin_image, keypoints, descriptors)
def test_pattern(self):
self.storage_service.save_pattern(self.pattern, overwrite=True)
pattern = self.storage_service.load_pattern(self.pattern_name)
self.assertEqual(self.pattern, pattern)
def test_settings(self):
self.storage_service.save_settings(self.settings, overwrite=True)
settings = self.storage_service.load_settings(self.settings_name)
self.assertEqual(self.settings, settings)
def platform_response(self, exception, notification_payload):
"""
## Trying to fix rate-limit or service down by retrying.
## After max of retries are exceeded we will log the payload
"""
exception_code = exception.code
exception_message = exception.msg
remaining_retries = \
notification_payload.get("remaining_retries", settings.NOTIFICATION_SENDING_MAX_TRIES + 1) - 1
logged = notification_payload.get("logged", False)
if exception_code in TwilioExceptionsCodes.RATE_LIMIT_LIST_CODES_EXCEPTION and remaining_retries > 0:
self.message_queue_dep.send(message=notification_payload)
elif not logged:
notification_payload.update({
"exception_code": exception_code,
"exception_message": exception_message,
"logged": True
})
notification_payload.pop("_id", None)
storage_service = StorageService()
storage_service.insert_failure(doc_data=notification_payload)
def platform_response(self, exception, notification_payload):
"""
# TODO check FCM exceptions to differentiate between
## Exceptions that we need to log it for monitoring
## Exceptions such as rate-limit or service down to retry.
"""
remaining_retries = \
notification_payload.get("remaining_retries", settings.NOTIFICATION_SENDING_MAX_TRIES + 1) - 1
logged = notification_payload.get("logged", False)
notification_payload.update({
"exception_message": exception.__repr__(),
"remaining_retries": remaining_retries,
"logged": logged
})
if remaining_retries == 0:
notification_payload.pop("_id", None)
storage_service = StorageService()
storage_service.insert_failure(doc_data=notification_payload)
notification_payload.update({"logged": True})
if remaining_retries > 0:
self.message_queue_dep.send(message=notification_payload)
def __init__(self, parent, model):
super().__init__()
self.parent = parent
self.model = model
self.storage_service = StorageService()
self.image_service = ImageService()
self.image_widget = ImageWidget(self)
self.model_box = self._create_model_box()
self.hbox = QHBoxLayout()
self.hbox.addWidget(self.image_widget)
self.hbox.addWidget(self.model_box)
self.model_box.setMaximumWidth(550)
self.setLayout(self.hbox)
def __init__(self, message_helper):
self.storage_service = StorageService()
self.message_helper = message_helper
class StorageHelper:
def __init__(self, message_helper):
self.storage_service = StorageService()
self.message_helper = message_helper
def add_new_transaction(self, transactions: List[StandardTransaction]):
"""
Проверяем есть ли новые транзации, и возвращаем только новые
:param transaction:
:return:
"""
# Запрос к СУБД на предмет новых транзакций
session = self.storage_service.create_session()
for item in transactions:
db_item = session.query(StandardTransaction).filter_by(
orderID=item.orderID).first()
if not db_item:
# Добавить в хранилище
session.add(item)
self.message_helper.send_notify("New transaction: \n" +
item.to_telegram_str())
elif db_item.ordStatus == "Filled":
# Пропускаем транзацкию если она завершена
continue
elif db_item.ordStatus == "Canceled":
# Пропускаем транзацкию если она завершена
continue
else:
if item.ordStatus != db_item.ordStatus:
session.query(StandardTransaction).filter_by(orderID=item.orderID).\
update({"ordStatus": item.ordStatus, "read_status": 0})
self.message_helper.send_notify("New status: \n" +
item.to_telegram_str())
if item.ordStatus == "Filled":
# Обновляем время завершения транзацкии что бы отчет таймера выполнить
self.time_filled_client_update(session, item.orderID)
session.commit()
session.close()
def read_transactions(self) -> List[StandardTransaction]:
session = self.storage_service.create_session()
unread_transaction = session.query(StandardTransaction).filter_by(
read_status=0).all()
for item in unread_transaction:
session.query(StandardTransaction).filter_by(orderID=item.orderID). \
update({"read_status": 1})
read_transaction = copy.deepcopy(unread_transaction)
session.commit()
session.close()
return read_transaction
def add_order(self, order: ClientTransaction):
session = self.storage_service.create_session()
session.add(order)
session.commit()
session.close()
def update_client_transaction(self,
transactions: List[StandardTransaction]):
# Запрос к СУБД на предмет новых транзакций
session = self.storage_service.create_session()
# storage_transactions = session.query(Transaction).filter(Transaction.orderID.in_(array_orders)).all()
for item in transactions:
db_item = session.query(ClientTransaction).filter_by(
orderID=item.orderID).first()
if not db_item:
pass
else:
if item.ordStatus != db_item.ordStatus:
session.query(ClientTransaction).filter_by(orderID=item.orderID). \
update({"ordStatus": item.ordStatus})
self.message_helper.send_notify("New status: \n" +
item.to_telegram_str())
session.commit()
session.close()
def get_client_order_by_reference(self, orderID_reference):
result = []
session = self.storage_service.create_session()
transactions = session.query(ClientTransaction).filter_by(
orderID_reference=orderID_reference).all()
for item in transactions:
result.append(item.orderID)
return result
def is_time_up(self, orderID):
session = self.storage_service.create_session()
transaction = session.query(ClientTransaction).filter_by(
orderID=orderID).first()
if not transaction:
return False
if transaction.time_up == 1:
return False
else:
return True
def get_client_order(self, orderID) -> ClientTransaction:
session = self.storage_service.create_session()
transaction = session.query(ClientTransaction).filter_by(
orderID=orderID).first()
session.expunge_all()
return transaction
def time_up_completed(self, orderID):
session = self.storage_service.create_session()
session.query(ClientTransaction).filter_by(orderID=orderID). \
update({"time_up": 1})
session.commit()
session.close()
def time_filled_client_update(self, session, orderID_reference):
time_filled_reference = datetime.datetime.utcnow().strftime(
"%Y-%m-%dT%H:%M:%S.%fZ")
session.query(ClientTransaction).filter_by(orderID_reference=orderID_reference). \
update({"time_filled_reference": time_filled_reference})
def setUp(self):
self.storage_service = StorageService()
self.pattern_name = 'test_pattern'
self.pattern = self.create_pattern(self.pattern_name)
self.settings_name = 'test_settings'
self.settings = Settings(self.settings_name)
def __init__(self):
self.storage_service = StorageService()
self.message_queue_dep = ConsumerMessageQueue()
def __init__(self):
self.storage_service = StorageService()
class StorageHelper:
def __init__(self):
self.storage_service = StorageService()
def user_add(self, user: User):
session = self.storage_service.create_session()
db_item = session.query(User).filter_by(telegram_id=user.telegram_id).first()
if not db_item:
# Добавить в хранилище
session.add(user)
session.commit()
session.close()
def get_active_users(self)->List[User]:
session = self.storage_service.create_session()
db_items = session.query(User).filter_by(status=True).all()
session.expunge_all()
session.close()
return db_items
def get_stat_users(self)->List[User]:
session = self.storage_service.create_session()
db_items = session.query(User).options(joinedload(User.parsers)).all()
session.expunge_all()
session.close()
return db_items
def user_change_status(self, telegram_id):
session = self.storage_service.create_session()
db_item = session.query(User).filter_by(telegram_id=telegram_id).first()
if db_item:
# Добавить в хранилище
db_item.status = not db_item.status
session.commit()
session.close()
def link_add(self, url):
session = self.storage_service.create_session()
db_item = session.query(LinkParser).filter_by(url=url).first()
if not db_item:
# Добавить в хранилище
session.add(LinkParser(url=url))
session.commit()
session.close()
def get_link_parser(self)->List[LinkParser]:
session = self.storage_service.create_session()
db_items = session.query(LinkParser).options(joinedload(LinkParser.users)).all()
session.expunge_all()
session.close()
return db_items
def add_parser_to_user(self, telegram_id, parser_id):
session = self.storage_service.create_session()
db_user = session.query(User).get(telegram_id)
db_parser = session.query(LinkParser).get(parser_id)
if db_user:
# Добавить в хранилище
db_user.parsers.append(db_parser)
session.commit()
session.close()
def del_parser_to_user(self, telegram_id, parser_id):
session = self.storage_service.create_session()
db_user = session.query(User).get(telegram_id)
db_parser = session.query(LinkParser).get(parser_id)
if db_user:
# Добавить в хранилище
db_user.parsers.remove(db_parser)
session.commit()
session.close()
def get_active_parser(self):
session = self.storage_service.create_session()
db_items = session.query(LinkParser).options(joinedload(LinkParser.users)).all()
active_parser = []
for parser in db_items:
active_users = [i for i in parser.users if (i.status and not i.user_block)]
if active_users:
active_parser.append(parser)
session.expunge_all()
session.close()
return active_parser
def add_products(self, products: List[Product]):
if not products:
return
session = self.storage_service.create_session()
for product in products:
db_item = session.query(Product).filter_by(url=product.url).first()
if not db_item:
session.add(product)
session.commit()
session.close()
def read_product(self) -> List[Product]:
session = self.storage_service.create_session()
unread_transaction = session.query(Product).filter_by(is_send=0).all()
for item in unread_transaction:
session.query(Product).filter_by(url=item.url). \
update({"is_send": 1})
read_product = copy.deepcopy(unread_transaction)
session.commit()
session.close()
return read_product
def link_del(self, parser_id):
session = self.storage_service.create_session()
db_item = session.query(LinkParser).get(parser_id)
if db_item:
# удалим в хранилище
session.delete(db_item)
session.commit()
session.close()
class MainWindow(QMainWindow):
def __init__(self, app):
super().__init__()
self.app = app
self.showMaximized()
self.image_service = ImageService()
self.storage_service = StorageService()
self.stacked_widget = QStackedWidget()
self.stacked_widget.showMaximized()
self.main_widget = MainWidget(self)
self.settings_widget = SettingsWidget(self, Settings())
self.pattern_widget = PatternWidget(self, Pattern())
self.stacked_widget.addWidget(self.main_widget)
self.stacked_widget.addWidget(self.pattern_widget)
self.stacked_widget.addWidget(self.settings_widget)
self.setCentralWidget(self.stacked_widget)
self.selected_pattern_name = None
self.selected_settings_name = None
self.pattern = None
self.settings = None
self._create_actions()
self._set_menu_bar()
self._set_tool_bar()
self.errors_color = QColor(255, 0, 0)
def _create_actions(self):
self.new_pattern_action = QAction(
QIcon(os.path.join(ICONS_DIR, 'add.png')), "New pattern", self)
self.new_pattern_action.triggered.connect(
self._new_pattern_action_handler)
self.new_settings_action = QAction(
QIcon(os.path.join(ICONS_DIR, 'settings.png')), "New settings",
self)
self.new_settings_action.triggered.connect(
self._new_settings_action_handler)
self.next_image_action = QAction(
QIcon(os.path.join(ICONS_DIR, 'next')), "Next image", self)
self.next_image_action.triggered.connect(
self._next_image_action_handler)
self.next_image_action.setEnabled(False)
self.errors_color_action = QAction(
QIcon(os.path.join(ICONS_DIR, 'color.png')), "Errors marker", self)
self.errors_color_action.triggered.connect(
self._errors_color_action_handler)
self.exit_action = QAction('Exit', self)
self.exit_action.triggered.connect(self.app.quit)
def _create_pattern_combo(self):
self.pattern_combo = QComboBox(self)
avaliable_pcbs = self.storage_service.get_avaliable_pattern_names()
for name in avaliable_pcbs:
self.pattern_combo.addItem(name)
self.pattern_combo.activated[str].connect(
self._selected_pattern_action_handler)
def _create_settings_combo(self):
self.settings_combo = QComboBox(self)
avaliable_settings_names = self.storage_service.get_avaliable_settings_names(
)
for name in avaliable_settings_names:
self.settings_combo.addItem(name)
self.settings_combo.activated[str].connect(
self._selected_settings_action_handler)
def _set_menu_bar(self):
menu_bar = self.menuBar()
menu_file = menu_bar.addMenu('File')
menu_file.addAction(self.new_pattern_action)
menu_file.addAction(self.exit_action)
def _set_tool_bar(self):
self._create_pattern_combo()
self._create_settings_combo()
self.tool_bar = self.addToolBar('Tools')
self.tool_bar.addWidget(self.pattern_combo)
self.tool_bar.addAction(self.new_pattern_action)
self.tool_bar.addSeparator()
self.tool_bar.addWidget(self.settings_combo)
self.tool_bar.addAction(self.new_settings_action)
self.tool_bar.addAction(self.errors_color_action)
self.tool_bar.addSeparator()
self.tool_bar.addAction(self.next_image_action)
def _new_pattern_action_handler(self):
file_dialog = QFileDialog(self)
file_dialog.setNameFilters(["All Files (*)", "Images (*.png *.jpg)"])
file_dialog.selectNameFilter("Images (*.png *.jpg)")
if file_dialog.exec_():
filename = file_dialog.selectedFiles()[0]
with wait_cursor():
image_orig = cv2.imread(filename, cv2.IMREAD_COLOR)
self.stacked_widget.removeWidget(self.pattern_widget)
self.settings_widget = PatternWidget(self, Pattern())
self.stacked_widget.addWidget(self.pattern_widget)
self.stacked_widget.setCurrentWidget(self.pattern_widget)
self.pattern_widget.setImage(image_orig)
self.pattern_widget.update()
def _new_settings_action_handler(self):
file_dialog = QFileDialog(self)
file_dialog.setNameFilters(["All Files (*)", "Images (*.png *.jpg)"])
file_dialog.selectNameFilter("Images (*.png *.jpg)")
if file_dialog.exec_():
filename = file_dialog.selectedFiles()[0]
with wait_cursor():
image_orig = cv2.imread(filename, cv2.IMREAD_COLOR)
self.stacked_widget.removeWidget(self.settings_widget)
self.settings_widget = SettingsWidget(self, Settings())
self.stacked_widget.addWidget(self.settings_widget)
self.stacked_widget.setCurrentWidget(self.settings_widget)
self.settings_widget.setImage(image_orig)
self.settings_widget.update()
def _next_image_action_handler(self):
#all requirements met, don't check again
image_orig = self.storage_service.next_image()
if image_orig != None:
with wait_cursor():
images = self.image_service.transform_image(
image_orig, self.settings)
images = self.image_service.compare(self.pattern, images,
self.settings)
bgr = [
self.errors_color.blue(),
self.errors_color.green(),
self.errors_color.red()
]
images = self.image_service.mark_errors(images, bgr)
self.stacked_widget.removeWidget(self.main_widget)
self.main_widget = MainWidget(self)
self.stacked_widget.addWidget(self.main_widget)
self.stacked_widget.setCurrentWidget(self.main_widget)
self.main_widget.setImage(images)
def _errors_color_action_handler(self):
color = QColorDialog.getColor()
if color.isValid():
self.errors_color = color
def _selected_pattern_action_handler(self, name):
self.selected_pattern_name = name
self.pattern = self.storage_service.load_pattern(
self.selected_pattern_name)
self._toggle_next_image_action()
def _selected_settings_action_handler(self, name):
self.selected_settings_name = name
self.settings = self.storage_service.load_settings(
self.selected_settings_name)
self._toggle_next_image_action()
def _toggle_next_image_action(self):
if self.selected_pattern_name and self.selected_pattern_name != PATTERN_COMBO_NAME and self.selected_settings_name and self.selected_settings_name != SETTINGS_COMBO_NAME:
self.next_image_action.setEnabled(True)
else:
self.next_image_action.setEnabled(False)
### PUBLIC METHODS ###
def pattern_finished(self, pattern_name):
if pattern_name:
self.pattern_combo.clear()
avaliable_pattern_names = self.storage_service.get_avaliable_pattern_names(
)
for name in avaliable_pattern_names:
self.pattern_combo.addItem(name)
index = self.pattern_combo.findText(pattern_name)
self.pattern_combo.setCurrentIndex(index)
self.selected_pattern_name = pattern_name
self._toggle_next_image_action()
self.stacked_widget.setCurrentWidget(self.main_widget)
def settings_finished(self, settings_name):
if settings_name:
self.settings_combo.clear()
avaliable_settings_names = self.storage_service.get_avaliable_settings_names(
)
for name in avaliable_settings_names:
self.settings_combo.addItem(name)
index = self.settings_combo.findText(settings_name)
self.settings_combo.setCurrentIndex(index)
self.selected_settings_name = name
self._toggle_next_image_action()
self.stacked_widget.setCurrentWidget(self.main_widget)