pyqtcli 0.1.0__tar.gz

pyqtcli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Маг Ильяс DOMA (MagIlyasDOMA)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyqtcli-0.1.0/PKG-INFO

@@ -0,0 +1,311 @@
+Metadata-Version: 2.4
+Name: pyqtcli
+Version: 0.1.0
+Summary: Package for supporting command-line arguments in Qt for Python applications
+Author-email: "Маг Ильяс DOMA (MagIlyasDOMA)" <magilyas.doma.09@list.ru>
+License: MIT
+Project-URL: Source, https://github.com/MagIlyasDOMA/pyqtcli
+Project-URL: Repository, https://github.com/MagIlyasDOMA/pyqtcli.git
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Natural Language :: English
+Classifier: Natural Language :: Russian
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argparse-typing>=0.2.0
+Provides-Extra: pyside
+Requires-Dist: Pyside2>=5.12.0; extra == "pyside"
+Provides-Extra: pyside2
+Requires-Dist: Pyside2>=5.12.0; extra == "pyside2"
+Provides-Extra: pyside6
+Requires-Dist: Pyside6>=6.0.0; extra == "pyside6"
+Provides-Extra: pyqt
+Requires-Dist: PyQt5>=5.0.0; extra == "pyqt"
+Provides-Extra: pyqt5
+Requires-Dist: PyQt5>=5.0.0; extra == "pyqt5"
+Provides-Extra: pyqt6
+Requires-Dist: PyQt6>=6.0.0; extra == "pyqt6"
+Provides-Extra: dev
+Requires-Dist: setuptools>=61.0.0; extra == "dev"
+Requires-Dist: wheel>=0.46.3; extra == "dev"
+Requires-Dist: twine>=6.2.0; extra == "dev"
+Requires-Dist: build>=1.4.0; extra == "dev"
+Dynamic: license-file
+
+<a id="doc_en"></a>
+# `pyqtcli` Documentation (PyQt/PySide CLI Integration)
+#### [Документация на русском](#doc_ru)
+
+**PyQtCLI** is a Python package that simplifies integrating command-line argument parsing into Qt-based GUI applications (PySide/PyQt). It allows you to easily combine the standard `argparse` module with the ability to display help messages in a graphical window (`QMessageBox`).
+
+## Features
+- **Backend Flexibility:** Automatically detects the available Qt binding (`PySide6`, `PyQt6`, `PyQt5`, `PySide2`).
+- **Graphical Help:** The `GUIHelpParser` class overrides the help output (`-h`, `--help`), displaying it not only in the console but also in a pop-up `QMessageBox` window.
+- **Convenient Mixin:** The `CLIMixin` class provides all the methods of `argparse.ArgumentParser` (`add_argument`, `parse_args`, etc.) for easy addition to your classes.
+- **Ready-to-Use Integration:** The `QCLIApplication` class is a ready-to-use subclass of `QApplication` with the `CLIMixin` functionality already built-in.
+- **Type Hints:** Includes `.pyi` files for better autocompletion and type checking support in modern IDEs.
+
+## Installation
+You can install the package directly from the repository or from PyPI after publication (replace with the actual command):
+
+```shell
+# From repository
+pip install git+https://github.com/MagIlyasDOMA/pyqtcli.git
+
+# Or after publication (example)
+pip install pyqtcli
+```
+
+The package does not automatically install a specific Qt library. You need to install one of the supported bindings yourself:
+
+```shell
+# For example, for PySide6
+pip install pyqtcli[pyside6]
+
+# Or for PyQt5
+pip install pyqtcli[pyqt5]
+```
+
+## Usage
+### Quick Start with QCLIApplication
+The easiest way to create an application with command-line argument support is to use the ready-made `QCLIApplication` class.
+
+```python
+import sys
+from pyqtcli import QCLIApplication
+from PySide6.QtWidgets import QMainWindow, QLabel # Example for PySide6
+
+# Create an application instance, passing the command-line arguments
+# All additional parameters (prog, description, etc.) are passed to the parser.
+app = QCLIApplication(
+    sys.argv,
+    description="My Super Application",
+    epilog="Example of using QCLIApplication"
+)
+
+# Add your own arguments, just like in standard argparse
+app.add_argument("-f", "--file", help="Path to the file to open")
+app.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output")
+
+# Parse the arguments. Help (-h) will automatically be displayed in a graphical window.
+args = app.parse_args()
+
+# --- Standard Qt application code follows ---
+window = QMainWindow()
+if args.file:
+    window.setCentralWidget(QLabel(f"Opened file: {args.file}"))
+else:
+    window.setCentralWidget(QLabel("Hello, world!"))
+window.show()
+
+sys.exit(app.exec())
+```
+
+### Using CLIMixin in Your Own QApplication Class
+If you need more control or want to add parsing functionality to your own application class, use `CLIMixin`.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication, QMainWindow, QLabel
+from pyqtcli import CLIMixin
+
+class MyApp(QApplication, CLIMixin):
+    def __init__(self, argv):
+        # First, initialize the mixin with parser parameters
+        CLIMixin.__init__(self, description="My Custom Application")
+        # Then initialize QApplication
+        QApplication.__init__(self, argv)
+
+        # Add your own arguments
+        self.add_argument("--debug", action="store_true", help="Enable debug mode")
+
+        # Parse the arguments
+        self.args = self.parse_args()
+
+        if self.args.debug:
+            print("Debug mode enabled")
+
+# Run the application
+if __name__ == "__main__":
+    app = MyApp(sys.argv)
+
+    window = QMainWindow()
+    window.setCentralWidget(QLabel("Application Window"))
+    window.show()
+
+    sys.exit(app.exec())
+```
+
+### Using GUIHelpParser Directly
+You can use the graphical parser directly, for example, to create a standalone tool.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication
+from pyqtcli.argparser import GUIHelpParser
+
+# Create the parser
+app = QApplication(sys.argv)
+parser = GUIHelpParser(prog="tool.py", description="Tool with GUI help")
+parser.add_argument("-o", "--output", help="File to save the result")
+
+# When parse_args() is called, help will be shown in a window
+# if the -h or --help arguments are passed.
+# Otherwise, parsing proceeds as usual.
+args = parser.parse_args()
+print(args)
+```
+
+Package Structure
+- `__init__.py`: The main module, exporting the `QCLIApplication`, `CLIMixin`, and `GUIHelpParser` classes.
+- `_widgets.py`: An internal module for automatically selecting and importing the required Qt binding.
+- `argparser.py`: Contains the `GUIHelpParser` (parser with graphical help) and `CLIMixin` (mixin for adding a parser to any class) classes.
+
+---
+
+<a id="doc_ru"></a>
+# Документация пакета `pyqtcli` (PyQt/PySide CLI Integration)
+#### [Documentation in English](#doc_en)
+
+**PyQtCLI** — это пакет для Python, который упрощает интеграцию парсинга аргументов командной строки в приложениях с графическим интерфейсом на базе Qt (PySide/PyQt). Он позволяет легко комбинировать стандартный `argparse` с возможностью отображения справки в графическом окне (`QMessageBox`).
+
+## Возможности
+- **Гибкость бэкенда:** Автоматически определяет доступную библиотеку Qt (`PySide6`, `PyQt6`, `PyQt5`, `PySide2`).
+- **Графическая справка:** Класс `GUIHelpParser` переопределяет вывод справки (`-h`, `--help`), отображая её не только в консоли, а в всплывающем окне `QMessageBox`.
+- **Удобный миксин:** Класс `CLIMixin` предоставляет все методы `argparse.ArgumentParser` (`add_argument`, `parse_args` и т.д.) для простого добавления в ваши классы.
+- **Готовая интеграция:** Класс `QCLIApplication` является готовым к использованию наследником `QApplication` с уже встроенным функционалом `CLIMixin`.
+- **Типизация:** В комплекте идут `.pyi` файлы для лучшей поддержки автодополнения и проверки типов в современных IDE.
+
+## Установка
+Установить пакет можно напрямую из репозитория или после публикации из PyPI (замените на актуальную команду):
+
+```shell
+# Из репозитория
+pip install git+https://github.com/MagIlyasDOMA/pyqtcli.git
+
+# Или после публикации (пример)
+pip install pyqtcli
+```
+
+Пакет не устанавливает автоматически конкретную Qt-библиотеку. Вам необходимо установить одну из поддерживаемых самостоятельно:
+
+```shell
+# Например, для PySide6
+pip install pyqtcli[pyside6]
+
+# Или для PyQt5
+pip install pyqtcli[pyqt5]
+```
+
+## Использование
+### Быстрый старт с QCLIApplication
+Самый простой способ создать приложение с поддержкой аргументов командной строки — использовать готовый класс `QCLIApplication`.
+
+```python
+import sys
+from pyqtcli import QCLIApplication
+from PySide6.QtWidgets import QMainWindow, QLabel # Пример для PySide6
+
+# Создаем экземпляр приложения, передавая аргументы командной строки
+# Все дополнительные параметры (prog, description и т.д.) уходят в парсер.
+app = QCLIApplication(
+    sys.argv,
+    description="Мое супер приложение",
+    epilog="Пример использования QCLIApplication"
+)
+
+# Добавляем свои аргументы, как в обычном argparse
+app.add_argument("-f", "--file", help="Путь к файлу для открытия")
+app.add_argument("-v", "--verbose", action="store_true", help="Подробный вывод")
+
+# Парсим аргументы. Справка (-h) автоматически отобразится в графическом окне.
+args = app.parse_args()
+
+# --- Здесь стандартный код Qt приложения ---
+window = QMainWindow()
+if args.file:
+    window.setCentralWidget(QLabel(f"Открыт файл: {args.file}"))
+else:
+    window.setCentralWidget(QLabel("Привет, мир!"))
+window.show()
+
+sys.exit(app.exec())
+```
+
+### Использование CLIMixin в своем классе QApplication
+Если вам нужно больше контроля или вы хотите добавить функционал парсинга в свой собственный класс приложения, используйте `CLIMixin`.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication, QMainWindow, QLabel
+from pyqtcli import CLIMixin
+
+class MyApp(QApplication, CLIMixin):
+    def __init__(self, argv):
+        # Сначала инициализируем миксин с параметрами парсера
+        CLIMixin.__init__(self, description="Мое кастомное приложение")
+        # Затем инициализируем QApplication
+        QApplication.__init__(self, argv)
+
+        # Добавляем свои аргументы
+        self.add_argument("--debug", action="store_true", help="Включить режим отладки")
+
+        # Парсим аргументы
+        self.args = self.parse_args()
+
+        if self.args.debug:
+            print("Отладка включена")
+
+# Запуск приложения
+if __name__ == "__main__":
+    app = MyApp(sys.argv)
+
+    window = QMainWindow()
+    window.setCentralWidget(QLabel("Окно приложения"))
+    window.show()
+
+    sys.exit(app.exec())
+```
+
+### Использование GUIHelpParser напрямую
+Вы можете использовать графический парсер напрямую, например, для создания отдельного инструмента.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication
+from pyqtcli.argparser import GUIHelpParser
+
+# Создаем парсер
+app = QApplication(sys.argv)
+parser = GUIHelpParser(prog="tool.py", description="Инструмент с GUI-справкой")
+parser.add_argument("-o", "--output", help="Файл для вывода результата")
+
+# При вызове parse_args() справка будет показана в окне,
+# если переданы аргументы -h или --help.
+# В противном случае парсинг пройдет как обычно.
+args = parser.parse_args()
+print(args)
+```
+
+## Структура пакета
+- `__init__.py`: Основной модуль, экспортирующий классы `QCLIApplication`, `CLIMixin` и `GUIHelpParser`.
+- `_widgets.py`: Внутренний модуль для автоматического выбора и импорта нужного Qt биндинга.
+- `argparser.py`: Содержит классы `GUIHelpParser` (парсер с графической справкой) и `CLIMixin` (миксин для добавления парсера в любой класс).

pyqtcli-0.1.0/README.md

@@ -0,0 +1,259 @@
+<a id="doc_en"></a>
+# `pyqtcli` Documentation (PyQt/PySide CLI Integration)
+#### [Документация на русском](#doc_ru)
+
+**PyQtCLI** is a Python package that simplifies integrating command-line argument parsing into Qt-based GUI applications (PySide/PyQt). It allows you to easily combine the standard `argparse` module with the ability to display help messages in a graphical window (`QMessageBox`).
+
+## Features
+- **Backend Flexibility:** Automatically detects the available Qt binding (`PySide6`, `PyQt6`, `PyQt5`, `PySide2`).
+- **Graphical Help:** The `GUIHelpParser` class overrides the help output (`-h`, `--help`), displaying it not only in the console but also in a pop-up `QMessageBox` window.
+- **Convenient Mixin:** The `CLIMixin` class provides all the methods of `argparse.ArgumentParser` (`add_argument`, `parse_args`, etc.) for easy addition to your classes.
+- **Ready-to-Use Integration:** The `QCLIApplication` class is a ready-to-use subclass of `QApplication` with the `CLIMixin` functionality already built-in.
+- **Type Hints:** Includes `.pyi` files for better autocompletion and type checking support in modern IDEs.
+
+## Installation
+You can install the package directly from the repository or from PyPI after publication (replace with the actual command):
+
+```shell
+# From repository
+pip install git+https://github.com/MagIlyasDOMA/pyqtcli.git
+
+# Or after publication (example)
+pip install pyqtcli
+```
+
+The package does not automatically install a specific Qt library. You need to install one of the supported bindings yourself:
+
+```shell
+# For example, for PySide6
+pip install pyqtcli[pyside6]
+
+# Or for PyQt5
+pip install pyqtcli[pyqt5]
+```
+
+## Usage
+### Quick Start with QCLIApplication
+The easiest way to create an application with command-line argument support is to use the ready-made `QCLIApplication` class.
+
+```python
+import sys
+from pyqtcli import QCLIApplication
+from PySide6.QtWidgets import QMainWindow, QLabel # Example for PySide6
+
+# Create an application instance, passing the command-line arguments
+# All additional parameters (prog, description, etc.) are passed to the parser.
+app = QCLIApplication(
+    sys.argv,
+    description="My Super Application",
+    epilog="Example of using QCLIApplication"
+)
+
+# Add your own arguments, just like in standard argparse
+app.add_argument("-f", "--file", help="Path to the file to open")
+app.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output")
+
+# Parse the arguments. Help (-h) will automatically be displayed in a graphical window.
+args = app.parse_args()
+
+# --- Standard Qt application code follows ---
+window = QMainWindow()
+if args.file:
+    window.setCentralWidget(QLabel(f"Opened file: {args.file}"))
+else:
+    window.setCentralWidget(QLabel("Hello, world!"))
+window.show()
+
+sys.exit(app.exec())
+```
+
+### Using CLIMixin in Your Own QApplication Class
+If you need more control or want to add parsing functionality to your own application class, use `CLIMixin`.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication, QMainWindow, QLabel
+from pyqtcli import CLIMixin
+
+class MyApp(QApplication, CLIMixin):
+    def __init__(self, argv):
+        # First, initialize the mixin with parser parameters
+        CLIMixin.__init__(self, description="My Custom Application")
+        # Then initialize QApplication
+        QApplication.__init__(self, argv)
+
+        # Add your own arguments
+        self.add_argument("--debug", action="store_true", help="Enable debug mode")
+
+        # Parse the arguments
+        self.args = self.parse_args()
+
+        if self.args.debug:
+            print("Debug mode enabled")
+
+# Run the application
+if __name__ == "__main__":
+    app = MyApp(sys.argv)
+
+    window = QMainWindow()
+    window.setCentralWidget(QLabel("Application Window"))
+    window.show()
+
+    sys.exit(app.exec())
+```
+
+### Using GUIHelpParser Directly
+You can use the graphical parser directly, for example, to create a standalone tool.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication
+from pyqtcli.argparser import GUIHelpParser
+
+# Create the parser
+app = QApplication(sys.argv)
+parser = GUIHelpParser(prog="tool.py", description="Tool with GUI help")
+parser.add_argument("-o", "--output", help="File to save the result")
+
+# When parse_args() is called, help will be shown in a window
+# if the -h or --help arguments are passed.
+# Otherwise, parsing proceeds as usual.
+args = parser.parse_args()
+print(args)
+```
+
+Package Structure
+- `__init__.py`: The main module, exporting the `QCLIApplication`, `CLIMixin`, and `GUIHelpParser` classes.
+- `_widgets.py`: An internal module for automatically selecting and importing the required Qt binding.
+- `argparser.py`: Contains the `GUIHelpParser` (parser with graphical help) and `CLIMixin` (mixin for adding a parser to any class) classes.
+
+---
+
+<a id="doc_ru"></a>
+# Документация пакета `pyqtcli` (PyQt/PySide CLI Integration)
+#### [Documentation in English](#doc_en)
+
+**PyQtCLI** — это пакет для Python, который упрощает интеграцию парсинга аргументов командной строки в приложениях с графическим интерфейсом на базе Qt (PySide/PyQt). Он позволяет легко комбинировать стандартный `argparse` с возможностью отображения справки в графическом окне (`QMessageBox`).
+
+## Возможности
+- **Гибкость бэкенда:** Автоматически определяет доступную библиотеку Qt (`PySide6`, `PyQt6`, `PyQt5`, `PySide2`).
+- **Графическая справка:** Класс `GUIHelpParser` переопределяет вывод справки (`-h`, `--help`), отображая её не только в консоли, а в всплывающем окне `QMessageBox`.
+- **Удобный миксин:** Класс `CLIMixin` предоставляет все методы `argparse.ArgumentParser` (`add_argument`, `parse_args` и т.д.) для простого добавления в ваши классы.
+- **Готовая интеграция:** Класс `QCLIApplication` является готовым к использованию наследником `QApplication` с уже встроенным функционалом `CLIMixin`.
+- **Типизация:** В комплекте идут `.pyi` файлы для лучшей поддержки автодополнения и проверки типов в современных IDE.
+
+## Установка
+Установить пакет можно напрямую из репозитория или после публикации из PyPI (замените на актуальную команду):
+
+```shell
+# Из репозитория
+pip install git+https://github.com/MagIlyasDOMA/pyqtcli.git
+
+# Или после публикации (пример)
+pip install pyqtcli
+```
+
+Пакет не устанавливает автоматически конкретную Qt-библиотеку. Вам необходимо установить одну из поддерживаемых самостоятельно:
+
+```shell
+# Например, для PySide6
+pip install pyqtcli[pyside6]
+
+# Или для PyQt5
+pip install pyqtcli[pyqt5]
+```
+
+## Использование
+### Быстрый старт с QCLIApplication
+Самый простой способ создать приложение с поддержкой аргументов командной строки — использовать готовый класс `QCLIApplication`.
+
+```python
+import sys
+from pyqtcli import QCLIApplication
+from PySide6.QtWidgets import QMainWindow, QLabel # Пример для PySide6
+
+# Создаем экземпляр приложения, передавая аргументы командной строки
+# Все дополнительные параметры (prog, description и т.д.) уходят в парсер.
+app = QCLIApplication(
+    sys.argv,
+    description="Мое супер приложение",
+    epilog="Пример использования QCLIApplication"
+)
+
+# Добавляем свои аргументы, как в обычном argparse
+app.add_argument("-f", "--file", help="Путь к файлу для открытия")
+app.add_argument("-v", "--verbose", action="store_true", help="Подробный вывод")
+
+# Парсим аргументы. Справка (-h) автоматически отобразится в графическом окне.
+args = app.parse_args()
+
+# --- Здесь стандартный код Qt приложения ---
+window = QMainWindow()
+if args.file:
+    window.setCentralWidget(QLabel(f"Открыт файл: {args.file}"))
+else:
+    window.setCentralWidget(QLabel("Привет, мир!"))
+window.show()
+
+sys.exit(app.exec())
+```
+
+### Использование CLIMixin в своем классе QApplication
+Если вам нужно больше контроля или вы хотите добавить функционал парсинга в свой собственный класс приложения, используйте `CLIMixin`.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication, QMainWindow, QLabel
+from pyqtcli import CLIMixin
+
+class MyApp(QApplication, CLIMixin):
+    def __init__(self, argv):
+        # Сначала инициализируем миксин с параметрами парсера
+        CLIMixin.__init__(self, description="Мое кастомное приложение")
+        # Затем инициализируем QApplication
+        QApplication.__init__(self, argv)
+
+        # Добавляем свои аргументы
+        self.add_argument("--debug", action="store_true", help="Включить режим отладки")
+
+        # Парсим аргументы
+        self.args = self.parse_args()
+
+        if self.args.debug:
+            print("Отладка включена")
+
+# Запуск приложения
+if __name__ == "__main__":
+    app = MyApp(sys.argv)
+
+    window = QMainWindow()
+    window.setCentralWidget(QLabel("Окно приложения"))
+    window.show()
+
+    sys.exit(app.exec())
+```
+
+### Использование GUIHelpParser напрямую
+Вы можете использовать графический парсер напрямую, например, для создания отдельного инструмента.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication
+from pyqtcli.argparser import GUIHelpParser
+
+# Создаем парсер
+app = QApplication(sys.argv)
+parser = GUIHelpParser(prog="tool.py", description="Инструмент с GUI-справкой")
+parser.add_argument("-o", "--output", help="Файл для вывода результата")
+
+# При вызове parse_args() справка будет показана в окне,
+# если переданы аргументы -h или --help.
+# В противном случае парсинг пройдет как обычно.
+args = parser.parse_args()
+print(args)
+```
+
+## Структура пакета
+- `__init__.py`: Основной модуль, экспортирующий классы `QCLIApplication`, `CLIMixin` и `GUIHelpParser`.
+- `_widgets.py`: Внутренний модуль для автоматического выбора и импорта нужного Qt биндинга.
+- `argparser.py`: Содержит классы `GUIHelpParser` (парсер с графической справкой) и `CLIMixin` (миксин для добавления парсера в любой класс).

pyqtcli-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyqtcli"
+version = "0.1.0"
+description = "Package for supporting command-line arguments in Qt for Python applications"
+readme = "README.md"
+authors = [
+    {name = "Маг Ильяс DOMA (MagIlyasDOMA)", email = "magilyas.doma.09@list.ru"},
+]
+license = {text = "MIT"}
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows :: Windows 10",
+    "Operating System :: Microsoft :: Windows :: Windows 11",
+    "Operating System :: OS Independent",
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Framework :: Django",
+    "Framework :: Django :: 5.2",
+    "Framework :: Django :: 6.0",
+    "Natural Language :: English",
+    "Natural Language :: Russian",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Utilities",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Security :: Cryptography",
+    "Topic :: Text Processing :: Markup",
+    "Topic :: Text Processing :: Markup :: HTML",
+]
+requires-python = ">=3.9"
+dependencies = ["argparse-typing>=0.2.0"]
+
+[project.optional-dependencies]
+pyside = ["Pyside2>=5.12.0"]
+pyside2 = ["Pyside2>=5.12.0"]
+pyside6 = ["Pyside6>=6.0.0"]
+pyqt = ["PyQt5>=5.0.0"]
+pyqt5 = ["PyQt5>=5.0.0"]
+pyqt6 = ["PyQt6>=6.0.0"]
+dev = [
+    "setuptools>=61.0.0",
+    "wheel>=0.46.3",
+    "twine>=6.2.0",
+    "build>=1.4.0"
+]
+
+[project.urls]
+Source = "https://github.com/MagIlyasDOMA/pyqtcli"
+Repository = "https://github.com/MagIlyasDOMA/pyqtcli.git"
+
+[tool.setuptools]
+packages = {find = {}}
+package-data = {"pyqtcli" = ["*.pyi", "py.typed"]}

pyqtcli-0.1.0/pyqtcli/__init__.py

@@ -0,0 +1,11 @@
+from ._widgets import QApplication
+from .argparser import CLIMixin, GUIHelpParser
+
+__version__ = '0.1.0'
+__all__ = ['QCLIApplication', 'CLIMixin', 'GUIHelpParser']
+
+
+class QCLIApplication(QApplication, CLIMixin):
+    def __init__(self, argv, *args, **kwargs):
+        CLIMixin.__init__(self, *args, **kwargs)
+        QApplication.__init__(self, argv)

pyqtcli-0.1.0/pyqtcli/__init__.pyi

@@ -0,0 +1,50 @@
+import sys
+from argparse import ArgumentParser, _FormatterClass
+from typing import Final, Sequence, Any
+from ._widgets import QApplication
+from .argparser import CLIMixin, GUIHelpParser
+
+__version__: Final[str] = '1.0.0'
+__all__: Final[str] = ['QCLIApplication', 'CLIMixin', 'GUIHelpParser']
+
+
+class QCLIApplication(QApplication, CLIMixin):
+    if sys.version_info >= (3, 14):
+        def __init__(
+            self,
+            argv: Sequence[str],
+            prog: str | None = None,
+            usage: str | None = None,
+            description: str | None = None,
+            epilog: str | None = None,
+            parents: Sequence[ArgumentParser] = [],
+            formatter_class: _FormatterClass = ...,
+            prefix_chars: str = "-",
+            fromfile_prefix_chars: str | None = None,
+            argument_default: Any = None,
+            conflict_handler: str = "error",
+            add_help: bool = True,
+            allow_abbrev: bool = True,
+            exit_on_error: bool = True,
+            *,
+            suggest_on_error: bool = False,
+            color: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            argv: Sequence[str],
+            prog: str | None = None,
+            usage: str | None = None,
+            description: str | None = None,
+            epilog: str | None = None,
+            parents: Sequence[ArgumentParser] = [],
+            formatter_class: _FormatterClass = ...,
+            prefix_chars: str = "-",
+            fromfile_prefix_chars: str | None = None,
+            argument_default: Any = None,
+            conflict_handler: str = "error",
+            add_help: bool = True,
+            allow_abbrev: bool = True,
+            exit_on_error: bool = True,
+        ) -> None: ...

pyqtcli-0.1.0/pyqtcli/_widgets.py

@@ -0,0 +1,24 @@
+import importlib
+
+
+# Определяем доступный Qt биндинг
+def get_qt_binding():
+    for binding in ['PySide6', 'PyQt6', 'PyQt5', 'PySide2']:
+        try:
+            module = importlib.import_module(f"{binding}.QtWidgets")
+            return binding, module
+        except ImportError:
+            continue
+    raise ImportError("No Qt binding found")
+
+
+QT_BINDING, QtWidgets = get_qt_binding()
+
+QApplication = QtWidgets.QApplication
+QMessageBox = QtWidgets.QMessageBox
+QMainWindow = QtWidgets.QMainWindow
+QWidget = QtWidgets.QWidget
+QDialog = QtWidgets.QDialog
+
+
+

pyqtcli-0.1.0/pyqtcli/argparser.py

@@ -0,0 +1,57 @@
+import argparse
+from ._widgets import QT_BINDING, QMessageBox
+
+__all__ = ['GUIHelpParser', 'CLIMixin']
+
+
+class GUIHelpParser(argparse.ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.messagebox = self._init_messagebox()
+
+    def _init_messagebox(self):
+        messagebox = QMessageBox()
+        messagebox.setWindowTitle("Help")
+
+        # Совместимость с разными версиями Qt
+        if QT_BINDING in ['PySide6', 'PyQt6']:
+            messagebox.setIcon(QMessageBox.Icon.Information)
+        else:  # PyQt5, PySide2
+            messagebox.setIcon(QMessageBox.Information)
+
+        messagebox.setText(self.format_help())
+        return messagebox
+
+    def print_help(self, file=None):
+        super().print_help(file)
+        try:
+            self.messagebox.exec()
+        except AttributeError:
+            self.messagebox.exec_()
+
+
+class CLIMixin:
+    def __init__(self, *args, **kwargs):
+        self.parser = GUIHelpParser(*args, **kwargs)
+
+    def add_argument(self, *name_or_flags, **kwargs):
+        return self.parser.add_argument(*name_or_flags, **kwargs)
+
+    def add_argument_group(self, *args, **kwargs):
+        return self.parser.add_argument_group(*args, **kwargs)
+
+    def add_mutually_exclusive_group(self, *args, **kwargs):
+        return self.parser.add_mutually_exclusive_group(*args, **kwargs)
+
+    def add_subparsers(self, *args, **kwargs):
+        return self.parser.add_subparsers(*args, **kwargs)
+
+    def parse_args(self, *args, **kwargs):
+        return self.parser.parse_args(*args, **kwargs)
+
+    def parse_known_args(self, *args, **kwargs):
+        return self.parser.parse_known_args(*args, **kwargs)
+
+    @property
+    def messagebox(self):
+        return self.parser.messagebox

pyqtcli-0.1.0/pyqtcli/argparser.pyi

@@ -0,0 +1,139 @@
+import sys
+from argparse import ArgumentParser, _N, Namespace, _SubParsersAction, Action, _FormatterClass, _ArgumentParserT, \
+    _ActionTyping, _NargsType, _ActionType, _T, _ArgumentGroup, _MutuallyExclusiveGroup
+from typing import Sequence, Any, overload, Optional, Iterable, Final
+from ._widgets import QMessageBox
+
+__all__: Final[str] = ['GUIHelpParser', 'CLIMixin']
+
+
+class GUIHelpParser(ArgumentParser):
+    def __init__(self, *args, **kwargs) -> None:
+        self.messagebox: QMessageBox = ...
+
+    def _init_messagebox(self) -> QMessageBox: ...
+
+    def print_help(self, file=None) -> None: ...
+
+class CLIMixin:
+    if sys.version_info >= (3, 14):
+        def __init__(
+                self,
+                prog: str | None = None,
+                usage: str | None = None,
+                description: str | None = None,
+                epilog: str | None = None,
+                parents: Sequence[ArgumentParser] = [],
+                formatter_class: _FormatterClass = ...,
+                prefix_chars: str = "-",
+                fromfile_prefix_chars: str | None = None,
+                argument_default: Any = None,
+                conflict_handler: str = "error",
+                add_help: bool = True,
+                allow_abbrev: bool = True,
+                exit_on_error: bool = True,
+                *,
+                suggest_on_error: bool = False,
+                color: bool = False,
+        ) -> None:
+            self.parser: GUIHelpParser = ...
+    else:
+        def __init__(
+                self,
+                prog: str | None = None,
+                usage: str | None = None,
+                description: str | None = None,
+                epilog: str | None = None,
+                parents: Sequence[ArgumentParser] = [],
+                formatter_class: _FormatterClass = ...,
+                prefix_chars: str = "-",
+                fromfile_prefix_chars: str | None = None,
+                argument_default: Any = None,
+                conflict_handler: str = "error",
+                add_help: bool = True,
+                allow_abbrev: bool = True,
+                exit_on_error: bool = True,
+        ) -> None:
+            self.parser: GUIHelpParser = ...
+
+    def add_argument(
+        self,
+        *name_or_flags: str,
+        # str covers predefined actions ("store_true", "count", etc.)
+        # and user registered actions via the `register` method.
+        action: _ActionTyping = ...,
+        # more precisely, Literal["?", "*", "+", "...", "A...", "==SUPPRESS=="],
+        # but using this would make it hard to annotate callers that don't use a
+        # literal argument and for subclasses to override this method.
+        nargs: Optional[_NargsType] = None,
+        const: Any = ...,
+        default: Any = ...,
+        type: _ActionType = ...,
+        choices: Iterable[_T] | None = ...,
+        required: bool = ...,
+        help: str | None = ...,
+        metavar: str | tuple[str, ...] | None = ...,
+        dest: str | None = ...,
+        version: str = ...,
+        **kwargs: Any,
+    ) -> Action: ...
+
+    def add_argument_group(
+        self,
+        title: str | None = None,
+        description: str | None = None,
+        *,
+        prefix_chars: str = ...,
+        argument_default: Any = ...,
+        conflict_handler: str = ...,
+    ) -> _ArgumentGroup: ...
+    def add_mutually_exclusive_group(self, *, required: bool = False) -> _MutuallyExclusiveGroup: ...
+
+    @overload
+    def parse_args(self, args: Sequence[str] | None = None, namespace: None = None) -> Namespace: ...
+    @overload
+    def parse_args(self, args: Sequence[str] | None, namespace: _N) -> _N: ...
+    @overload
+    def parse_args(self, *, namespace: _N) -> _N: ...
+
+    @overload
+    def add_subparsers(
+            self: _ArgumentParserT,
+            *,
+            title: str = "subcommands",
+            description: str | None = None,
+            prog: str | None = None,
+            action: type[Action] = ...,
+            option_string: str = ...,
+            dest: str | None = None,
+            required: bool = False,
+            help: str | None = None,
+            metavar: str | None = None,
+    ) -> _SubParsersAction[_ArgumentParserT]: ...
+    @overload
+    def add_subparsers(
+            self,
+            *,
+            title: str = "subcommands",
+            description: str | None = None,
+            prog: str | None = None,
+            parser_class: type[_ArgumentParserT],
+            action: type[Action] = ...,
+            option_string: str = ...,
+            dest: str | None = None,
+            required: bool = False,
+            help: str | None = None,
+            metavar: str | None = None,
+    ) -> _SubParsersAction[_ArgumentParserT]: ...
+
+    @overload
+    def parse_known_args(self, args: Sequence[str] | None = None, namespace: None = None) -> tuple[
+        Namespace, list[str]]: ...
+    @overload
+    def parse_known_args(self, args: Sequence[str] | None, namespace: _N) -> tuple[_N, list[str]]: ...
+    @overload
+    def parse_known_args(self, *, namespace: _N) -> tuple[_N, list[str]]: ...
+
+    @property
+    def messagebox(self) -> QMessageBox:
+        return self.parser.messagebox

pyqtcli-0.1.0/pyqtcli.egg-info/PKG-INFO

@@ -0,0 +1,311 @@
+Metadata-Version: 2.4
+Name: pyqtcli
+Version: 0.1.0
+Summary: Package for supporting command-line arguments in Qt for Python applications
+Author-email: "Маг Ильяс DOMA (MagIlyasDOMA)" <magilyas.doma.09@list.ru>
+License: MIT
+Project-URL: Source, https://github.com/MagIlyasDOMA/pyqtcli
+Project-URL: Repository, https://github.com/MagIlyasDOMA/pyqtcli.git
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Natural Language :: English
+Classifier: Natural Language :: Russian
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argparse-typing>=0.2.0
+Provides-Extra: pyside
+Requires-Dist: Pyside2>=5.12.0; extra == "pyside"
+Provides-Extra: pyside2
+Requires-Dist: Pyside2>=5.12.0; extra == "pyside2"
+Provides-Extra: pyside6
+Requires-Dist: Pyside6>=6.0.0; extra == "pyside6"
+Provides-Extra: pyqt
+Requires-Dist: PyQt5>=5.0.0; extra == "pyqt"
+Provides-Extra: pyqt5
+Requires-Dist: PyQt5>=5.0.0; extra == "pyqt5"
+Provides-Extra: pyqt6
+Requires-Dist: PyQt6>=6.0.0; extra == "pyqt6"
+Provides-Extra: dev
+Requires-Dist: setuptools>=61.0.0; extra == "dev"
+Requires-Dist: wheel>=0.46.3; extra == "dev"
+Requires-Dist: twine>=6.2.0; extra == "dev"
+Requires-Dist: build>=1.4.0; extra == "dev"
+Dynamic: license-file
+
+<a id="doc_en"></a>
+# `pyqtcli` Documentation (PyQt/PySide CLI Integration)
+#### [Документация на русском](#doc_ru)
+
+**PyQtCLI** is a Python package that simplifies integrating command-line argument parsing into Qt-based GUI applications (PySide/PyQt). It allows you to easily combine the standard `argparse` module with the ability to display help messages in a graphical window (`QMessageBox`).
+
+## Features
+- **Backend Flexibility:** Automatically detects the available Qt binding (`PySide6`, `PyQt6`, `PyQt5`, `PySide2`).
+- **Graphical Help:** The `GUIHelpParser` class overrides the help output (`-h`, `--help`), displaying it not only in the console but also in a pop-up `QMessageBox` window.
+- **Convenient Mixin:** The `CLIMixin` class provides all the methods of `argparse.ArgumentParser` (`add_argument`, `parse_args`, etc.) for easy addition to your classes.
+- **Ready-to-Use Integration:** The `QCLIApplication` class is a ready-to-use subclass of `QApplication` with the `CLIMixin` functionality already built-in.
+- **Type Hints:** Includes `.pyi` files for better autocompletion and type checking support in modern IDEs.
+
+## Installation
+You can install the package directly from the repository or from PyPI after publication (replace with the actual command):
+
+```shell
+# From repository
+pip install git+https://github.com/MagIlyasDOMA/pyqtcli.git
+
+# Or after publication (example)
+pip install pyqtcli
+```
+
+The package does not automatically install a specific Qt library. You need to install one of the supported bindings yourself:
+
+```shell
+# For example, for PySide6
+pip install pyqtcli[pyside6]
+
+# Or for PyQt5
+pip install pyqtcli[pyqt5]
+```
+
+## Usage
+### Quick Start with QCLIApplication
+The easiest way to create an application with command-line argument support is to use the ready-made `QCLIApplication` class.
+
+```python
+import sys
+from pyqtcli import QCLIApplication
+from PySide6.QtWidgets import QMainWindow, QLabel # Example for PySide6
+
+# Create an application instance, passing the command-line arguments
+# All additional parameters (prog, description, etc.) are passed to the parser.
+app = QCLIApplication(
+    sys.argv,
+    description="My Super Application",
+    epilog="Example of using QCLIApplication"
+)
+
+# Add your own arguments, just like in standard argparse
+app.add_argument("-f", "--file", help="Path to the file to open")
+app.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output")
+
+# Parse the arguments. Help (-h) will automatically be displayed in a graphical window.
+args = app.parse_args()
+
+# --- Standard Qt application code follows ---
+window = QMainWindow()
+if args.file:
+    window.setCentralWidget(QLabel(f"Opened file: {args.file}"))
+else:
+    window.setCentralWidget(QLabel("Hello, world!"))
+window.show()
+
+sys.exit(app.exec())
+```
+
+### Using CLIMixin in Your Own QApplication Class
+If you need more control or want to add parsing functionality to your own application class, use `CLIMixin`.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication, QMainWindow, QLabel
+from pyqtcli import CLIMixin
+
+class MyApp(QApplication, CLIMixin):
+    def __init__(self, argv):
+        # First, initialize the mixin with parser parameters
+        CLIMixin.__init__(self, description="My Custom Application")
+        # Then initialize QApplication
+        QApplication.__init__(self, argv)
+
+        # Add your own arguments
+        self.add_argument("--debug", action="store_true", help="Enable debug mode")
+
+        # Parse the arguments
+        self.args = self.parse_args()
+
+        if self.args.debug:
+            print("Debug mode enabled")
+
+# Run the application
+if __name__ == "__main__":
+    app = MyApp(sys.argv)
+
+    window = QMainWindow()
+    window.setCentralWidget(QLabel("Application Window"))
+    window.show()
+
+    sys.exit(app.exec())
+```
+
+### Using GUIHelpParser Directly
+You can use the graphical parser directly, for example, to create a standalone tool.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication
+from pyqtcli.argparser import GUIHelpParser
+
+# Create the parser
+app = QApplication(sys.argv)
+parser = GUIHelpParser(prog="tool.py", description="Tool with GUI help")
+parser.add_argument("-o", "--output", help="File to save the result")
+
+# When parse_args() is called, help will be shown in a window
+# if the -h or --help arguments are passed.
+# Otherwise, parsing proceeds as usual.
+args = parser.parse_args()
+print(args)
+```
+
+Package Structure
+- `__init__.py`: The main module, exporting the `QCLIApplication`, `CLIMixin`, and `GUIHelpParser` classes.
+- `_widgets.py`: An internal module for automatically selecting and importing the required Qt binding.
+- `argparser.py`: Contains the `GUIHelpParser` (parser with graphical help) and `CLIMixin` (mixin for adding a parser to any class) classes.
+
+---
+
+<a id="doc_ru"></a>
+# Документация пакета `pyqtcli` (PyQt/PySide CLI Integration)
+#### [Documentation in English](#doc_en)
+
+**PyQtCLI** — это пакет для Python, который упрощает интеграцию парсинга аргументов командной строки в приложениях с графическим интерфейсом на базе Qt (PySide/PyQt). Он позволяет легко комбинировать стандартный `argparse` с возможностью отображения справки в графическом окне (`QMessageBox`).
+
+## Возможности
+- **Гибкость бэкенда:** Автоматически определяет доступную библиотеку Qt (`PySide6`, `PyQt6`, `PyQt5`, `PySide2`).
+- **Графическая справка:** Класс `GUIHelpParser` переопределяет вывод справки (`-h`, `--help`), отображая её не только в консоли, а в всплывающем окне `QMessageBox`.
+- **Удобный миксин:** Класс `CLIMixin` предоставляет все методы `argparse.ArgumentParser` (`add_argument`, `parse_args` и т.д.) для простого добавления в ваши классы.
+- **Готовая интеграция:** Класс `QCLIApplication` является готовым к использованию наследником `QApplication` с уже встроенным функционалом `CLIMixin`.
+- **Типизация:** В комплекте идут `.pyi` файлы для лучшей поддержки автодополнения и проверки типов в современных IDE.
+
+## Установка
+Установить пакет можно напрямую из репозитория или после публикации из PyPI (замените на актуальную команду):
+
+```shell
+# Из репозитория
+pip install git+https://github.com/MagIlyasDOMA/pyqtcli.git
+
+# Или после публикации (пример)
+pip install pyqtcli
+```
+
+Пакет не устанавливает автоматически конкретную Qt-библиотеку. Вам необходимо установить одну из поддерживаемых самостоятельно:
+
+```shell
+# Например, для PySide6
+pip install pyqtcli[pyside6]
+
+# Или для PyQt5
+pip install pyqtcli[pyqt5]
+```
+
+## Использование
+### Быстрый старт с QCLIApplication
+Самый простой способ создать приложение с поддержкой аргументов командной строки — использовать готовый класс `QCLIApplication`.
+
+```python
+import sys
+from pyqtcli import QCLIApplication
+from PySide6.QtWidgets import QMainWindow, QLabel # Пример для PySide6
+
+# Создаем экземпляр приложения, передавая аргументы командной строки
+# Все дополнительные параметры (prog, description и т.д.) уходят в парсер.
+app = QCLIApplication(
+    sys.argv,
+    description="Мое супер приложение",
+    epilog="Пример использования QCLIApplication"
+)
+
+# Добавляем свои аргументы, как в обычном argparse
+app.add_argument("-f", "--file", help="Путь к файлу для открытия")
+app.add_argument("-v", "--verbose", action="store_true", help="Подробный вывод")
+
+# Парсим аргументы. Справка (-h) автоматически отобразится в графическом окне.
+args = app.parse_args()
+
+# --- Здесь стандартный код Qt приложения ---
+window = QMainWindow()
+if args.file:
+    window.setCentralWidget(QLabel(f"Открыт файл: {args.file}"))
+else:
+    window.setCentralWidget(QLabel("Привет, мир!"))
+window.show()
+
+sys.exit(app.exec())
+```
+
+### Использование CLIMixin в своем классе QApplication
+Если вам нужно больше контроля или вы хотите добавить функционал парсинга в свой собственный класс приложения, используйте `CLIMixin`.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication, QMainWindow, QLabel
+from pyqtcli import CLIMixin
+
+class MyApp(QApplication, CLIMixin):
+    def __init__(self, argv):
+        # Сначала инициализируем миксин с параметрами парсера
+        CLIMixin.__init__(self, description="Мое кастомное приложение")
+        # Затем инициализируем QApplication
+        QApplication.__init__(self, argv)
+
+        # Добавляем свои аргументы
+        self.add_argument("--debug", action="store_true", help="Включить режим отладки")
+
+        # Парсим аргументы
+        self.args = self.parse_args()
+
+        if self.args.debug:
+            print("Отладка включена")
+
+# Запуск приложения
+if __name__ == "__main__":
+    app = MyApp(sys.argv)
+
+    window = QMainWindow()
+    window.setCentralWidget(QLabel("Окно приложения"))
+    window.show()
+
+    sys.exit(app.exec())
+```
+
+### Использование GUIHelpParser напрямую
+Вы можете использовать графический парсер напрямую, например, для создания отдельного инструмента.
+
+```python
+import sys
+from PySide6.QtWidgets import QApplication
+from pyqtcli.argparser import GUIHelpParser
+
+# Создаем парсер
+app = QApplication(sys.argv)
+parser = GUIHelpParser(prog="tool.py", description="Инструмент с GUI-справкой")
+parser.add_argument("-o", "--output", help="Файл для вывода результата")
+
+# При вызове parse_args() справка будет показана в окне,
+# если переданы аргументы -h или --help.
+# В противном случае парсинг пройдет как обычно.
+args = parser.parse_args()
+print(args)
+```
+
+## Структура пакета
+- `__init__.py`: Основной модуль, экспортирующий классы `QCLIApplication`, `CLIMixin` и `GUIHelpParser`.
+- `_widgets.py`: Внутренний модуль для автоматического выбора и импорта нужного Qt биндинга.
+- `argparser.py`: Содержит классы `GUIHelpParser` (парсер с графической справкой) и `CLIMixin` (миксин для добавления парсера в любой класс).

pyqtcli-0.1.0/pyqtcli.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+pyqtcli/__init__.py
+pyqtcli/__init__.pyi
+pyqtcli/_widgets.py
+pyqtcli/argparser.py
+pyqtcli/argparser.pyi
+pyqtcli/py.typed
+pyqtcli.egg-info/PKG-INFO
+pyqtcli.egg-info/SOURCES.txt
+pyqtcli.egg-info/dependency_links.txt
+pyqtcli.egg-info/requires.txt
+pyqtcli.egg-info/top_level.txt

pyqtcli-0.1.0/pyqtcli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyqtcli-0.1.0/pyqtcli.egg-info/requires.txt

@@ -0,0 +1,25 @@
+argparse-typing>=0.2.0
+
+[dev]
+setuptools>=61.0.0
+wheel>=0.46.3
+twine>=6.2.0
+build>=1.4.0
+
+[pyqt]
+PyQt5>=5.0.0
+
+[pyqt5]
+PyQt5>=5.0.0
+
+[pyqt6]
+PyQt6>=6.0.0
+
+[pyside]
+Pyside2>=5.12.0
+
+[pyside2]
+Pyside2>=5.12.0
+
+[pyside6]
+Pyside6>=6.0.0

pyqtcli-0.1.0/pyqtcli.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+pyqtcli

pyqtcli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+