Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

разница from pywinauto import Application, ElementNotFoundError и from…

  1. User

    разница from pywinauto import Application, ElementNotFoundError

    и

    from pywinauto.application import Application from pywinauto.findwindows import ElementNotFoundError

  2. Assistant

    Разница между двумя способами импорта в Python из библиотеки pywinauto связана с тем, как организованы модули внутри пакета и где именно находятся классы/исключения, которые вы импортируете:

    # Вариант 1:
    from pywinauto import Application, ElementNotFoundError
    
    # Вариант 2:
    from pywinauto.application import Application
    from pywinauto.findwindows import ElementNotFoundError
    

    Объяснение:

    1. Структура библиотеки pywinauto:
    • Application находится в подмодуле pywinauto.application.
    • ElementNotFoundError находится в подмодуле pywinauto.findwindows.
    1. Вариант 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.
    1. Вариант 2 (импорт непосредственно с указанием модулей):
    • Здесь импорт происходит напрямую из тех подмодулей, где определены объекты.
    • Это более явный и надёжный способ, так как вы точно указываете, откуда берёте Application и ElementNotFoundError.
    • В случае, если в будущем структура пакета изменится, этот способ тоже нужно будет корректировать, но сейчас он более универсален.

    Какой вариант лучше использовать?

    • Специфический импорт напрямую из подмодулей (вариант 2) считается более корректным с точки зрения структуры и читаемости кода, а также более "безопасным" в плане совместимости.
    • Импорт из главного пакета (вариант 1) удобен, если пакет официально поддерживает такой способ импортирования (имеет корректный __init__.py), и делается для удобства пользователей.

    Итог:

    ВариантОткуда происходит импортПлюсыМинусы
    from pywinauto import ApplicationИз главного пакета (через __init__.py)Коротко, удобноМожет не работать, если не экспортировано явно
    from pywinauto.application import ApplicationИз конкретного подмодуляЯвно, надёжноБольше строк, явное указание

    Если вы не уверены, какой вариант использовать, берите второй — он наверняка не вызовет проблем.

  3. 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_logger
    

    def 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("Основной скрипт завершил выполнение.")

  4. 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("Основной скрипт завершил выполнение.")
    

    Альтернативные варианты:

    1. Инициализировать логгер заранее — ещё до попыток обработки исключений:
    logger = init_logging()
    
    def main():
        global logger
        # logger уже инициализирован
        # ...
    

    Однако если init_logging() наверняка использует или импортирует какой-то код, который может упасть, то лучше оставлять инициализацию в main().

    1. Использовать модульный логгер с 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("Основной скрипт завершил выполнение.")
    

    Если хотите — могу помочь улучшить конфигурацию логгера, чтобы минимизировать подобные ситуации.

  5. 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_logger
    

    logger = 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("Основной скрипт завершил выполнение.")

  6. 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() возвращает валидный логгер.


    На что обратить внимание?

    1. Убедитесь, что 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 возникает та же ошибка.


    1. Проверьте импорт 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.


    1. Резюме и решение
    • Убедитесь, что setup_logger возвращает объект логгера.
    • Если он не возвращает — исправьте setup_logger или измените init_logging так, чтобы она возвращала логгер, например:
    def init_logging():
        setup_logger("root")   # предположим, что эта функция настраивает логгер, но ничего не возвращает
        return logging.getLogger("root")
    

    Итог

    Скорее всего проблема в том, что:

    root_logger = setup_logger("root")
    

    возвращает None.

    Решение:

    1. Проверьте setup_logger — должен возвращать объект Logger.
    2. Либо адаптируйте 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 — помогу адаптировать.

  7. User

    есть разница между user32 = ctypes.windll.user32 и user32 = win32api.LoadLibrary("user32.dll")

  8. 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 и т.п.

    Если интересно — могу помочь с примерами или более глубоким объяснением.

  9. 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()
    
  10. 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_window

    win32gui.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.

  11. User

    а можно универсально логировать модуль и метод вызова, чтобы не писать та кogger.debug("main_app.find_target_process Вызов")

  12. 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Автоматическая запись в лог при входе в функциюДекорировать нужные функции для автологирования

    Если нужна помощь с конкретной реализацией или интеграцией — спрашивайте!

  13. 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
    
  14. Assistant

    Спасибо за код!
    Вставлю в ваш текущий код два улучшения:

    1. Добавлю в форматтер логов %(module)s.%(funcName)s():%(lineno)d — чтобы автоматически выводился модуль и функция с номером строки вызова.
    2. Добавлю в 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 | Тестовое сообщение
    

    Если нужно — могу помочь с более продвинутым логированием (например, с поддержкой разных обработчиков, файловым логом и т.п.).

  15. 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
    
  16. 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
    

    Преимущества:

    • Можно вызвать отдельно поиск только поля или только кнопки.
    • Легко тестировать и переиспользовать по отдельности.
    • Логи точнее и локализованы по функциям.
    • Высокая читаемость и поддерживаемость.

    Если потребуется, можно добавить параметры с возможностью переопределить критерии!