разница from pywinauto import Application, ElementNotFoundError и from…
- User
разница from pywinauto import Application, ElementNotFoundError
и
from pywinauto.application import Application from pywinauto.findwindows import ElementNotFoundError
- Assistant
Разница между двумя способами импорта в Python из библиотеки pywinauto связана с тем, как организованы модули внутри пакета и где именно находятся классы/исключения, которые вы импортируете:
# Вариант 1: from pywinauto import Application, ElementNotFoundError# Вариант 2: from pywinauto.application import Application from pywinauto.findwindows import ElementNotFoundError
Объяснение:
- Структура библиотеки pywinauto:
Applicationнаходится в подмодулеpywinauto.application.ElementNotFoundErrorнаходится в подмодулеpywinauto.findwindows.
- Вариант 1 (
from pywinauto import ...):
- В данном случае вы импортируете
ApplicationиElementNotFoundErrorнапрямую из основного пакетаpywinauto. - Для этого в
__init__.pyпакетаpywinautoдолжны быть прописаны соответствующие строки, которые делают эти классы/исключения доступными напрямую. Например:
from .application import Application from .findwindows import ElementNotFoundError- Если в вашей версии pywinauto в
pywinauto/__init__.pyэти объекты не равномерно экспортируются, то импорт черезfrom pywinauto import Applicationможет привести к ошибке ImportError.
- Вариант 2 (импорт непосредственно с указанием модулей):
- Здесь импорт происходит напрямую из тех подмодулей, где определены объекты.
- Это более явный и надёжный способ, так как вы точно указываете, откуда берёте
ApplicationиElementNotFoundError. - В случае, если в будущем структура пакета изменится, этот способ тоже нужно будет корректировать, но сейчас он более универсален.
Какой вариант лучше использовать?
- Специфический импорт напрямую из подмодулей (
вариант 2) считается более корректным с точки зрения структуры и читаемости кода, а также более "безопасным" в плане совместимости. - Импорт из главного пакета (
вариант 1) удобен, если пакет официально поддерживает такой способ импортирования (имеет корректный__init__.py), и делается для удобства пользователей.
Итог:
Вариант Откуда происходит импорт Плюсы Минусы from pywinauto import ApplicationИз главного пакета (через __init__.py)Коротко, удобно Может не работать, если не экспортировано явно from pywinauto.application import ApplicationИз конкретного подмодуля Явно, надёжно Больше строк, явное указание
Если вы не уверены, какой вариант использовать, берите второй — он наверняка не вызовет проблем.
- User
проблема Cannot find reference 'critical' in 'None'
import tkinter as tk import traceback import pythoncom
import ctypes.wintypes import logging
from logger_setup import setup_logger from Win.settings.config import load_settings, save_settings from Win.gui.app_gui import AppGUI
logger = None
def init_logging(): # Инициализируем root-логгер (или глобальные настройки) root_logger = setup_logger("root")
# Инициализируем все существующие логгеры (опционально) loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict] for lg in loggers: setup_logger(lg.name) return root_loggerdef main(): global logger
logger = init_logging() try: pythoncom.CoInitializeEx(pythoncom.COINIT_APARTMENTTHREADED) except pythoncom.com_error as e: logger.warning(f"Ошибка CoInitializeEx: {e}. COM может быть уже инициализирован.") load_settings(logger) # Загружаем настройки # init_redis_keys() # Если используете Redis # load_uia_module() # Если используете UIAutomation root_tk = tk.Tk() app = AppGUI(root_tk) root_tk.mainloop() save_settings(logger) # Сохранение настроек pythoncom.CoUninitialize() logger.info("Программа завершена.")if name == "main": try: main() except Exception as e_main: logger.critical(f"Необработанное исключение в main: {e_main}\n{traceback.format_exc()}") finally: logger.info("Основной скрипт завершил выполнение.")
- Assistant
Ошибка:
Cannot find reference 'critical' in 'None'означает, что в момент вызова
logger.critical(...)переменнаяloggerравнаNone— то есть объект логгера не инициализирован.
Почему так происходит?
Посмотрите вашу структуру:
logger = None def main(): global logger logger = init_logging() # ... # работа с logger, который инициализирован if __name__ == "__main__": try: main() except Exception as e_main: logger.critical(...)То есть внутри блока
if __name__ == "__main__":вы вызываетеmain(), где происходит инициализацияlogger. Но если ошибка возникнет ещё до того, какmain()вызоветlogger = init_logging(), например, при импорте модулей или ошибке в самомmain(), тогда в блокеexceptглобальная переменнаяloggerвсё еще равна None.
Как это исправить?
Чтобы безопасно вызывать
logger.criticalв блокеexcept, нужно удостовериться, чтоloggerне равенNoneили иметь запасной вариант на случай, если логгер не инициализирован.Например, можно сделать так:
if __name__ == "__main__": try: main() except Exception as e_main: if logger: logger.critical(f"Необработанное исключение в main: {e_main}\n{traceback.format_exc()}") else: print(f"CRITICAL: Необработанное исключение в main: {e_main}\n{traceback.format_exc()}") finally: if logger: logger.info("Основной скрипт завершил выполнение.") else: print("Основной скрипт завершил выполнение.")
Альтернативные варианты:
- Инициализировать логгер заранее — ещё до попыток обработки исключений:
logger = init_logging() def main(): global logger # logger уже инициализирован # ...Однако если
init_logging()наверняка использует или импортирует какой-то код, который может упасть, то лучше оставлять инициализацию вmain().- Использовать модульный логгер с fallback
import logging logger = logging.getLogger("fallback") logger.setLevel(logging.DEBUG) if not logger.hasHandlers(): ch = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') ch.setFormatter(formatter) logger.addHandler(ch)И при запуске уже переопределять
loggerчерез функциюinit_logging(), но в любом случае логгер всегда будет хотя бы один.
Итог
Для вашей ситуации — самый простой и быстрый способ — сделать проверку в блоке
except:if logger is not None: logger.critical(...) else: print(...)
Пример правки вашего кода для безопасной отработки исключений:
if __name__ == "__main__": try: main() except Exception as e_main: if logger: logger.critical(f"Необработанное исключение в main: {e_main}\n{traceback.format_exc()}") else: print(f"CRITICAL: Необработанное исключение в main: {e_main}\n{traceback.format_exc()}") finally: if logger: logger.info("Основной скрипт завершил выполнение.") else: print("Основной скрипт завершил выполнение.")
Если хотите — могу помочь улучшить конфигурацию логгера, чтобы минимизировать подобные ситуации.
- User
import tkinter as tk import traceback import pythoncom
import ctypes.wintypes import logging
from logger_setup import setup_logger from Win.settings.config import load_settings, save_settings from Win.gui.app_gui import AppGUI
def init_logging(): # Инициализируем root-логгер (или глобальные настройки) root_logger = setup_logger("root")
# Инициализируем все существующие логгеры (опционально) loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict] for lg in loggers: setup_logger(lg.name) return root_loggerlogger = init_logging()
def main(): global logger
try: pythoncom.CoInitializeEx(pythoncom.COINIT_APARTMENTTHREADED) except pythoncom.com_error as e: logger.warning(f"Ошибка CoInitializeEx: {e}. COM может быть уже инициализирован.") load_settings(logger) # Загружаем настройки # init_redis_keys() # Если используете Redis # load_uia_module() # Если используете UIAutomation root_tk = tk.Tk() app = AppGUI(root_tk) root_tk.mainloop() save_settings(logger) # Сохранение настроек pythoncom.CoUninitialize() logger.info("Программа завершена.")if name == "main": try: main() except Exception as e: logger.critical(f"Необработанное исключение в main: {e}\n{traceback.format_exc()}") finally: logger.info("Основной скрипт завершил выполнение.")
- Assistant
В вашем обновлённом коде вы инициализируете
loggerдо вызоваmain(), сразу при загрузке модуля:logger = init_logging()Это значит, что в блоке
exceptпри обработке исключений в:if __name__ == "__main__": try: main() except Exception as e: logger.critical(...) finally: logger.info(...)логгер уже точно инициализирован, и ошибка
Cannot find reference 'critical' in 'None'не должна появляться, при условии чтоinit_logging()возвращает валидный логгер.
На что обратить внимание?
- Убедитесь, что
setup_logger()действительно возвращает логгер.
Пример корректной реализации
setup_logger:def setup_logger(name): logger = logging.getLogger(name) if not logger.hasHandlers(): handler = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) logger.setLevel(logging.DEBUG) return loggerЕсли
setup_loggerничего не возвращает (None), тоinit_loggingприсваиваетroot_logger = None. Тогда при вызовеlogger.criticalвозникает та же ошибка.
- Проверьте импорт
logger_setupи функциюsetup_logger()
Вызов
init_logging():def init_logging(): root_logger = setup_logger("root") # Должен вернуть Logger # Инициализируем все логи других логгеров (если нужно) loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict] for lg in loggers: setup_logger(lg.name) # не обязательно присваивать, если setup_logger модифицирует логгер return root_loggerЕсли
setup_loggerне возвращает ничего — тоroot_loggerбудетNone.
- Резюме и решение
- Убедитесь, что
setup_loggerвозвращает объект логгера. - Если он не возвращает — исправьте
setup_loggerили изменитеinit_loggingтак, чтобы она возвращала логгер, например:
def init_logging(): setup_logger("root") # предположим, что эта функция настраивает логгер, но ничего не возвращает return logging.getLogger("root")
Итог
Скорее всего проблема в том, что:
root_logger = setup_logger("root")возвращает
None.Решение:
- Проверьте
setup_logger— должен возвращать объектLogger. - Либо адаптируйте
init_logging:
def init_logging(): setup_logger("root") # если setup_logger не возвращает, то просто получаем логгер вручную: root_logger = logging.getLogger("root") loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict] for lg in loggers: setup_logger(lg.name) return root_logger
Пример исправленного блока:
def init_logging(): setup_logger("root") root_logger = logging.getLogger("root") loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict] for lg in loggers: setup_logger(lg.name) return root_logger logger = init_logging()
Если нужно, можете скинуть реализацию
setup_logger— помогу адаптировать. - Убедитесь, что
- User
есть разница между user32 = ctypes.windll.user32 и user32 = win32api.LoadLibrary("user32.dll")
- Assistant
Да, разница есть, и она связана с тем, как именно происходит загрузка библиотеки и с какими объектами вы работаете:
1.
user32 = ctypes.windll.user32- Это стандартный способ загрузить динамическую библиотеку Windows (
user32.dll) через ctypes — стандартный модуль Python. - Возвращаемый объект — это динамический прокси для DLL, через который вы можете вызывать функции библиотеки, например:
user32.MessageBoxW(None, "Hello", "Title", 0)ctypes.windllподразумевает, что функции в DLL используют стандарты вызова WINAPI (stdcall), что обычно верно для Windows API.- Простая, кроссплатформенная (только Windows) обертка без дополнительных зависимостей.
2.
user32 = win32api.LoadLibrary("user32.dll")- Это вызов из библиотеки pywin32 — специализированного набора расширений для взаимодействия с WinAPI.
- Функция
LoadLibraryиз win32api загружает DLL вручную и возвращает дескриптор модуля (handle), это вродеHMODULEв WinAPI. - Это не обертка для вызова функций, а просто числовой дескриптор загруженного модуля.
- Чтобы вызвать функцию, вам нужно работать с ним через низкоуровневые вызовы (например, через
GetProcAddressи т.п.) — pywin32 в этом плане более низкоуровневый.
Важные отличия
Пункт ctypes.windll.user32win32api.LoadLibrary("user32.dll")Результат Объект, через который легко вызываются функции Дескриптор (handle) загруженной DLL Уровень абстракции Высокий — удобно вызывать функции прямо Низкий — нужно вручную искать и вызывать функции Зависимости Стандартный модуль Python Необходимо устанавливать pywin32 Основное назначение Удобная интеграция с WinAPI Управление модулями, загрузка/выгрузка DLL
Пример вызова MessageBox:
import ctypes user32 = ctypes.windll.user32 user32.MessageBoxW(0, "Hello", "Title", 0)Для pywin32 нужно загружать дополнительно функции или использовать другие модули PyWin:
import win32api hMod = win32api.LoadLibrary("user32.dll") # Но чтобы вызвать функцию, придется применять GetProcAddress, ctypes или другие методы
Когда что использовать?
- Если нужно просто вызвать функции из Windows API — проще использовать
ctypesиwindll. - Если используете возможности pywin32 для других целей, и нужна работа с загрузкой DLL напрямую — используйте
win32api.LoadLibrary. - Иногда можно комбинировать — взять дескриптор из win32api, а вызвать функцию через ctypes, передав туда
HMODULEи т.п.
Если интересно — могу помочь с примерами или более глубоким объяснением.
- Это стандартный способ загрузить динамическую библиотеку Windows (
- User
я планирую такое сделать
import tkinter as tk from tkinter import ttk, messagebox import threading import time import win32gui import win32api import win32con import logging
logger = logging.getLogger(name)
user32 = win32api.LoadLibrary("user32.dll")
def enable_window(hwnd, enable=True): # Включить/выключить взаимодействие с окном try: win32gui.EnableWindow(hwnd, enable) except Exception as e: logger.error(f"Ошибка при изменении состояния окна: {e}")
def activate_window(hwnd): try: win32gui.SetForegroundWindow(hwnd) except Exception as e: logger.error(f"Ошибка при активации окна: {e}")
class StartupMonitor(tk.Toplevel): def init(self, parent, find_target_process_and_window_func, check_camera_func): super().init(parent) self.title("Запуск мониторинга") self.geometry("400x150") self.resizable(False, False) self.protocol("WM_DELETE_WINDOW", self.on_close)
self.parent = parent self.find_target_process_and_window = find_target_process_and_window_func self.check_camera = check_camera_func self.progress = ttk.Progressbar(self, length=350, mode='determinate', maximum=4) self.progress.pack(pady=20) self.status_label = tk.Label(self, text="Инициализация...") self.status_label.pack(pady=5) self.cancelled = False self.target_hwnd = None self.thread = threading.Thread(target=self.run_startup_sequence, daemon=True) self.thread.start() def on_close(self): if messagebox.askokcancel("Отмена", "Прервать запуск мониторинга?"): self.cancelled = True def run_startup_sequence(self): try: # 1. Поиск процесса и окна EzCad2 self.update_status("Поиск процесса EzCad2...") for i in range(10): if self.cancelled: self.finish_with_error("Запуск отменён пользователем.") return main_win, target_element, target_button, pid = self.find_target_process_and_window() if main_win: self.target_hwnd = main_win.handle break time.sleep(0.5) else: self.finish_with_error("Процесс EzCad2 не найден.") return # Блокируем окно EzCad2 (делаем неактивным) enable_window(self.target_hwnd, False) # Активируем окно на передний план activate_window(self.target_hwnd) self.progress.step(1) self.update_status("Поиск целевых элементов...") # 2. Поиск целевых элементов (поле ввода и кнопка) for i in range(10): if self.cancelled: self.finish_with_error("Запуск отменён пользователем.") enable_window(self.target_hwnd, True) return main_win, target_element, target_button, pid = self.find_target_process_and_window() if target_element and target_button: break time.sleep(0.5) else: self.finish_with_error("Целевые элементы не найдены.") enable_window(self.target_hwnd, True) return self.progress.step(1) self.update_status("Проверка соединения с камерой...") # 3. Проверка камеры (фейковая функция, заменить на реальную) if not self.check_camera(): self.finish_with_error("Камера не подключена.") enable_window(self.target_hwnd, True) return self.progress.step(1) self.update_status("Установка хуков...") # 4. Здесь можно добавить установку хуков, если нужно time.sleep(1) # эмуляция self.progress.step(1) self.update_status("Запуск завершён успешно.") time.sleep(0.5) # Разблокируем окно EzCad2, т.к. запуск завершён enable_window(self.target_hwnd, True) # Закрываем окно прогресса self.after(500, self.destroy) except Exception as e: logger.error(f"Ошибка в процессе запуска: {e}") self.finish_with_error(f"Ошибка: {e}") if self.target_hwnd: enable_window(self.target_hwnd, True) def update_status(self, text): self.status_label.config(text=text) def finish_with_error(self, message): messagebox.showerror("Ошибка запуска", message, parent=self) self.destroy() - Assistant
В целом код выглядит очень неплохо и правильно: вы создаёте модальное окно с прогрессбаром, делаете пошаговую инициализацию — всё это в отдельном потоке, не блокируя GUI.
Несколько комментариев и рекомендаций для улучшения и повышения надежности:
1. Использование
win32api.LoadLibrary("user32.dll")Вы нигде не используете переменную
user32, которую присваиваете:user32 = win32api.LoadLibrary("user32.dll")Если вы планируете работать с функциями из user32.dll — в pywin32 для вызова функций надо использовать win32gui, win32api и т.п. напрямую, либо использовать
ctypes.windll.user32.Этот вызов загружает DLL и возвращает хэндл, но вы его не используете.
Рекомендация:
Если вам не нужно напрямую работать с низкоуровневыми функциями, просто уберите эту строку. Или работайте через
ctypes.windll.user32:import ctypes user32 = ctypes.windll.user32 user32.EnableWindow(hwnd, True)
2. Потокобезопасность обновления UI
Вы запускаете поток:
self.thread = threading.Thread(target=self.run_startup_sequence, daemon=True) self.thread.start()И из этого потока вызываете методы, которые обновляют UI:
self.update_status("Текст") self.progress.step(1)В Tkinter обновление UI должно происходить из главного потока! Иначе возможны ошибки или зависания.
Для потокобезопасного обновления используйте метод
after(). Например, оборачивайте обновления так:def update_status(self, text): self.after(0, lambda: self.status_label.config(text=text)) def progress_step(self): self.after(0, lambda: self.progress.step(1))А в
run_startup_sequenceвызывайте:self.update_status("Поиск процесса EzCad2...") self.progress_step()Или создайте отдельный метод для обновления прогресса.
3. Разблокировка окна — важна в каждом варианте
Вы уже делаете это при ошибках — хорошо!
Только убедитесь, что при любом исключении окно не останется заблокированным. Окружите ваш код в
run_startup_sequenceвtry-finally, в котором вfinallyвы всегда разблокируете окно, если оно было заблокировано.
4. Метод
activate_windowwin32gui.SetForegroundWindowможет выкидыватьwin32gui.errorесли невозможно привести окно к переднему плану (например, в новых версиях Windows есть ограничения).Если хотите повысить надежность, можно попытаться:
- вызвать
win32gui.ShowWindow(hwnd, win32con.SW_SHOW) - вызвать
win32gui.SetForegroundWindow(hwnd) - при ошибках — логировать, или попробовать через
AttachThreadInput(сложнее)
5. Замечания по функции
find_target_process_and_windowВы передаёте функцию в конструктор:
def __init__(self, parent, find_target_process_and_window_func, check_camera_func): ...Убедитесь, что у этой функции корректно возвращаются ожидаемые значения:
main_win, target_element, target_button, pid.А также что у объекта
main_winесть атрибут.handle. Если это, например, объект изpywinauto, то да.
6. Пример реализации потокобезопасного обновления UI
Добавьте методы для обновления UI в главном потоке:
def update_status(self, text): self.after(0, lambda: self.status_label.config(text=text)) def progress_step(self): self.after(0, self.progress.step, 1)И вызывайте их из потока.
7. Пример оборванного кода для
enable_windowЕсли вы хотите, чтобы она (функция) работала через
ctypes(альтернатива):import ctypes def enable_window(hwnd, enable=True): user32 = ctypes.windll.user32 user32.EnableWindow(hwnd, enable)Ваш вариант через
win32gui.EnableWindowтоже корректен.
Итог: пример с потокобезопасным обновлением UI
def update_status(self, text): self.after(0, lambda: self.status_label.config(text=text)) def progress_step(self): self.after(0, lambda: self.progress.step(1))И в
run_startup_sequence:self.update_status("Поиск процесса EzCad2...") # вместо self.progress.step(1) self.progress_step()
Если нужно, могу помочь с полной версией вашего класса с учётом потокобезопасных обновлений и улучшений работы с окнами WinAPI.
- вызвать
- User
а можно универсально логировать модуль и метод вызова, чтобы не писать та кogger.debug("main_app.find_target_process Вызов")
- Assistant
Да, можно логировать автоматически модуль и функцию (метод), откуда сделан вызов, без явного указания каждого раза в сообщении. Для этого обычно используют возможности встроенного модуля
logging— в частности, форматтер (formatter) с нужным шаблоном, плюс можно в коде получать текущие модуль/функцию динамически.
1. Автоматический вывод модуля и функции через Formatter логгера
Самый простой и надежный способ — настроить формат логов с использованием атрибутов записи лога:
%(module)s— имя модуля (файла без расширения)%(funcName)s— имя функции/метода, из которой сделан вызов лога%(lineno)d— номер строки
Например, форматтер:
formatter = logging.Formatter('%(asctime)s | %(levelname)s | %(module)s.%(funcName)s():%(lineno)d | %(message)s')Это значит, что каждый лог автоматически будет содержать информацию, кто вызвал лог.
2. Пример настройки логгера с таким форматером
import logging logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) formatter = logging.Formatter('%(asctime)s | %(levelname)s | %(module)s.%(funcName)s():%(lineno)d | %(message)s') ch.setFormatter(formatter) logger.addHandler(ch) def example_func(): logger.debug("Пример сообщения") if __name__ == "__main__": example_func()Пример вывода в консоли:
2024-06-20 10:00:00,123 | DEBUG | mymodule.example_func():10 | Пример сообщения
3. Если все равно нужен автоматический вызов логирования с определением модуля и функции
Если в самой функции хочется автоматически логировать начало работы (например, "Вызов функции"), а не писать вручную
logger.debug("main_app.find_target_process Вызов"), можно сделать декоратор, который будет логировать вход в функцию с указанием её имени и модуля.
Декоратор для автоматического логирования входа в функцию
import logging import functools logger = logging.getLogger(__name__) def log_call(func): @functools.wraps(func) def wrapper(*args, **kwargs): logger.debug(f"Вызов {func.__module__}.{func.__qualname__}()") return func(*args, **kwargs) return wrapper # Использование: @log_call def find_target_process(): # тело функции passПри вызове
find_target_process()в лог автоматически выведется строка:DEBUG:__main__:Вызов mymodule.find_target_process()
4. Заключение
Способ Для чего Как использовать Форматтер с %(module)s.%(funcName)s()Для автоматической вставки модуля и функции в каждый лог Настроить форматтер логгера Декоратор @log_callАвтоматическая запись в лог при входе в функцию Декорировать нужные функции для автологирования
Если нужна помощь с конкретной реализацией или интеграцией — спрашивайте!
- User
вот мой код. встрой туда это
import logging from datetime import datetime
arm_loggers = {}
class CustomFormatter(logging.Formatter): converter = datetime.fromtimestamp
# Цвета ANSI для разных уровней COLORS = { 'DEBUG': '\033[94m', # синий 'INFO': '\033[92m', # зелёный 'WARNING': '\033[93m', # жёлтый 'ERROR': '\033[91m', # красный 'CRITICAL': '\033[41m', # красный фон } RESET = '\033[0m' def formatTime(self, record, datefmt=None): ct = self.converter(record.created) if datefmt: s = ct.strftime(datefmt) # Подставляем миллисекунды вместо {ms} if "{ms}" in s: ms = f"{int(record.msecs):03d}" s = s.replace("{ms}", ms) else: s = f"{s}.{int(record.msecs):03d}" else: t = ct.strftime("%Y-%m-%d %H:%M:%S") s = f"{t},{int(record.msecs):03d}" return s def format(self, record): color = self.COLORS.get(record.levelname, self.RESET) message = super().format(record) return f"{color}{message}{self.RESET}"def setup_logger(name=None): formatter = CustomFormatter(fmt='[%(asctime)s] %(levelname)s: %(message)s', datefmt='%H:%M:%S.{ms}')
global arm_loggers if arm_loggers.get(name): return arm_loggers.get(name) else: logger = logging.getLogger(name) if not logger.hasHandlers(): ch = logging.StreamHandler() ch.setFormatter(formatter) logger.setLevel(logging.DEBUG) # Можно менять уровень # logger.handlers = [] logger.addHandler(ch) arm_loggers[name] = logger return logger - Assistant
Спасибо за код!
Вставлю в ваш текущий код два улучшения:- Добавлю в форматтер логов
%(module)s.%(funcName)s():%(lineno)d— чтобы автоматически выводился модуль и функция с номером строки вызова. - Добавлю в
setup_loggerвозможность использовать изменённый формат.
Ваш обновлённый код с моими правками:
import logging from datetime import datetime arm_loggers = {} class CustomFormatter(logging.Formatter): converter = datetime.fromtimestamp # Цвета ANSI для разных уровней COLORS = { 'DEBUG': '\033[94m', # синий 'INFO': '\033[92m', # зелёный 'WARNING': '\033[93m', # жёлтый 'ERROR': '\033[91m', # красный 'CRITICAL': '\033[41m', # красный фон } RESET = '\033[0m' def formatTime(self, record, datefmt=None): ct = self.converter(record.created) if datefmt: s = ct.strftime(datefmt) # Подставляем миллисекунды вместо {ms} if "{ms}" in s: ms = f"{int(record.msecs):03d}" s = s.replace("{ms}", ms) else: s = f"{s}.{int(record.msecs):03d}" else: t = ct.strftime("%Y-%m-%d %H:%M:%S") s = f"{t},{int(record.msecs):03d}" return s def format(self, record): color = self.COLORS.get(record.levelname, self.RESET) message = super().format(record) return f"{color}{message}{self.RESET}" def setup_logger(name=None): # Добавил в fmt вывод модуля, функции и строки fmt = '[%(asctime)s] %(levelname)s: %(module)s.%(funcName)s():%(lineno)d | %(message)s' formatter = CustomFormatter(fmt=fmt, datefmt='%H:%M:%S.{ms}') global arm_loggers if arm_loggers.get(name): return arm_loggers.get(name) else: logger = logging.getLogger(name) if not logger.hasHandlers(): ch = logging.StreamHandler() ch.setFormatter(formatter) logger.setLevel(logging.DEBUG) # Можно менять уровень logger.addHandler(ch) arm_loggers[name] = logger return logger
Что изменилось:
-
Формат в
fmtтеперь включает:
%(module)s- имя вашего модуля (файла без расширения)
%(funcName)s- имя функции или метода, откуда вызван лог
%(lineno)d- номер строки с вызовом -
В логах будет, например:
[10:15:30.123] DEBUG: mymodule.my_function():42 | Начало выполнения -
Цвета сохраняются, как в вашем оригинале.
Дополнительно (по желанию):
Если хотите, чтобы в некоторых местах автоматом логировался вход в функцию, то можно описать простой декоратор, который будет вызывать
logger.debug().
Я могу помочь и с этим, если нужно.
Если захотите протестировать, то:
logger = setup_logger(__name__) def test(): logger.debug("Тестовое сообщение") if __name__ == "__main__": test()Выведет:
[10:15:30.123] DEBUG: yourmodule.test():8 | Тестовое сообщение
Если нужно — могу помочь с более продвинутым логированием (например, с поддержкой разных обработчиков, файловым логом и т.п.).
- Добавлю в форматтер логов
- User
а можно разбить или сделать универсально внутри метода чтобы вызывать отдельно разный поиск
def find_target_elements(main_win): """ Поиск целевых элементов (поле ввода и кнопка) внутри окна main_win. Возвращает: (target_element, target_button) или (None, None) при ошибке. """ if main_win is None: logger.error("Передано пустое главное окно для поиска элементов.") return None, None
# Поиск поля ввода field_criteria_config = TARGET_ELEMENT_CONFIG.get("search_criteria", {}) active_field_criteria = {k: v for k, v in field_criteria_config.items() if v} target_element = None if not active_field_criteria: logger.error("В конфиге не заданы критерии поиска для целевого поля ввода.") else: search_criteria = { "auto_id": active_field_criteria.get("automation_id"), "title": active_field_criteria.get("title"), "class_name": active_field_criteria.get("class_name") } try: target_element = main_win.child_window(**search_criteria) target_element.wait('exists', timeout=5) logger.info(f"Найдено целевое поле с критериями {search_criteria}: HWND={target_element.handle}") except ElementNotFoundError: logger.warning(f"Не найдено целевое поле с критериями: {search_criteria}.") # Поиск кнопки button_criteria_config = TARGET_ELEMENT_CONFIG.get("button_search_criteria", {}) active_button_criteria = {k: v for k, v in button_criteria_config.items() if v} target_button = None if not active_button_criteria: logger.error("В конфиге не заданы критерии поиска для целевой кнопки.") else: button_criteria = { "auto_id": active_button_criteria.get("automation_id"), "title": active_button_criteria.get("title"), "class_name": active_button_criteria.get("class_name") } try: target_button = main_win.child_window(**button_criteria) target_button.wait('exists', timeout=5) logger.info(f"Найдена целевая кнопка с критериями {button_criteria}: HWND={target_button.handle}") except ElementNotFoundError: logger.warning(f"Не найдена целевая кнопка с критериями: {button_criteria}.") return target_element, target_button - Assistant
Да, функцию
find_target_elementsможно универсально разбить на отдельные методы, каждый из которых будет искать конкретный элемент по заданным критериям. Это улучшит читаемость, переиспользуемость и позволит проще логировать/обрабатывать ошибки для каждого типа поиска.Пример структурирования:
def find_target_element(main_win): """ Поиск целевого поля ввода внутри main_win. Возвращает найденный элемент или None. """ if main_win is None: logger.error("Передано пустое главное окно для поиска целевого поля.") return None criteria_config = TARGET_ELEMENT_CONFIG.get("search_criteria", {}) active_criteria = {k: v for k, v in criteria_config.items() if v} if not active_criteria: logger.error("В конфиге не заданы критерии поиска для целевого поля ввода.") return None search_criteria = { "auto_id": active_criteria.get("automation_id"), "title": active_criteria.get("title"), "class_name": active_criteria.get("class_name") } try: target_element = main_win.child_window(**search_criteria) target_element.wait('exists', timeout=5) logger.info(f"Найдено целевое поле с критериями {search_criteria}: HWND={target_element.handle}") return target_element except ElementNotFoundError: logger.warning(f"Не найдено целевое поле с критериями: {search_criteria}.") return None def find_target_button(main_win): """ Поиск целевой кнопки внутри main_win. Возвращает найденный элемент или None. """ if main_win is None: logger.error("Передано пустое главное окно для поиска кнопки.") return None criteria_config = TARGET_ELEMENT_CONFIG.get("button_search_criteria", {}) active_criteria = {k: v for k, v in criteria_config.items() if v} if not active_criteria: logger.error("В конфиге не заданы критерии поиска для целевой кнопки.") return None search_criteria = { "auto_id": active_criteria.get("automation_id"), "title": active_criteria.get("title"), "class_name": active_criteria.get("class_name") } try: target_button = main_win.child_window(**search_criteria) target_button.wait('exists', timeout=5) logger.info(f"Найдена целевая кнопка с критериями {search_criteria}: HWND={target_button.handle}") return target_button except ElementNotFoundError: logger.warning(f"Не найдена целевая кнопка с критериями: {search_criteria}.") return None def find_target_elements(main_win): """ Универсальная функция, возвращающая кортеж (целевое поле, кнопка) """ target_element = find_target_element(main_win) target_button = find_target_button(main_win) return target_element, target_button
Преимущества:
- Можно вызвать отдельно поиск только поля или только кнопки.
- Легко тестировать и переиспользовать по отдельности.
- Логи точнее и локализованы по функциям.
- Высокая читаемость и поддерживаемость.
Если потребуется, можно добавить параметры с возможностью переопределить критерии!