fastqt6 0.1.0__tar.gz

fastqt6-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leevandr
+
+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.

fastqt6-0.1.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: fastqt6
+Version: 0.1.0
+Summary: Convenient PyQt6 templates for dynamic forms, CRUD windows, Designer .ui files and SQL helpers
+Author: Leevandr
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Leevandr/fastQT6
+Project-URL: Repository, https://github.com/Leevandr/fastQT6
+Keywords: pyqt6,qt,designer,mysql,crud,forms
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyQt6>=6.6
+Requires-Dist: PyMySQL>=1.1
+Dynamic: license-file
+
+# fastqt6
+
+`fastqt6` - это небольшая библиотека-шаблон для PyQt6-проектов: динамические формы,
+CRUD-окна, SQL-хелперы и генерация `.ui` файлов для Qt Designer.
+
+Установка после публикации:
+
+```bash
+pip install fastqt6
+```
+
+Локальная установка из репозитория:
+
+```bash
+python -m pip install -e .
+```
+
+## Быстрый пример
+
+```python
+from PyQt6.QtWidgets import QApplication
+from fastqt6 import SQLDatabase, field
+from fastqt6.widgets import CrudWindow
+
+SCHEMA = """
+create table if not exists products (
+    id integer primary key autoincrement,
+    article text not null,
+    title text not null,
+    price real not null default 0,
+    stock integer not null default 0
+);
+"""
+
+app = QApplication([])
+db = SQLDatabase.sqlite("app.db")
+db.run_script(SCHEMA)
+
+window = CrudWindow(
+    db,
+    table="products",
+    fields=[
+        field("article", "Артикул", required=True),
+        field("title", "Название", required=True),
+        field("price", "Цена", "float", min_value=0),
+        field("stock", "Остаток", "int", min_value=0),
+    ],
+)
+window.show()
+app.exec()
+```
+
+## SQL-хелперы
+
+SQLite:
+
+```python
+from fastqt6 import SQLDatabase
+
+db = SQLDatabase.sqlite("app.db")
+db.insert("products", {"article": "A-1", "title": "Мяч", "price": 1000})
+rows = db.select("products", where="price > ?", params=(500,), order_by="title")
+db.update("products", {"price": 1200}, "id=?", (1,))
+db.delete("products", "id=?", (1,))
+```
+
+MySQL:
+
+```python
+from fastqt6 import SQLDatabase
+
+db = SQLDatabase.mysql("sportplus_kvalik", user="root", password="")
+user = db.login("users", "admin", "admin")
+rows = db.fetch_all("select * from products where title like ?", ("%мяч%",))
+```
+
+В запросах можно писать `?` как универсальный placeholder. Для MySQL библиотека
+сама заменит его на `%s`.
+
+## Динамические формы
+
+```python
+from fastqt6 import field
+from fastqt6.forms import DynamicFormDialog
+
+fields = [
+    field("article", "Артикул", required=True),
+    field("title", "Название", required=True),
+    field("price", "Цена", "float", min_value=0),
+    field("category_id", "Категория", "combo", choices=[("Мячи", 1), ("Обувь", 2)]),
+]
+
+dialog = DynamicFormDialog(fields, title="Товар")
+if dialog.exec():
+    data = dialog.get_data()
+```
+
+## Генерация файлов Qt Designer
+
+Создать `auth.ui`:
+
+```bash
+fastqt6 ui-auth ui/auth.ui
+```
+
+Создать главное окно с вкладками:
+
+```bash
+fastqt6 ui-main ui/main.ui --tabs "Каталог,Мои заказы,Все заказы,Статистика"
+```
+
+Создать форму:
+
+```bash
+fastqt6 ui-form ui/product.ui \
+  --title "Товар" \
+  --class-name "ProductDialog" \
+  --field article:text:Артикул \
+  --field title:text:Название \
+  --field price:float:Цена \
+  --field stock:int:Остаток
+```
+
+После этого файл можно открыть в Qt Designer или конвертировать:
+
+```bash
+pyuic6 ui/product.ui -o gen/product.py
+```
+
+## CLI
+
+```text
+fastqt6 scaffold my_app
+fastqt6 ui-auth ui/auth.ui
+fastqt6 ui-main ui/main.ui
+fastqt6 ui-form ui/form.ui --field title:text:Название
+```
+
+## Что вводить на PyPI Trusted Publisher
+
+Для репозитория `git@github.com:Leevandr/fastQT6.git` заполни форму так:
+
+```text
+PyPI Project Name: fastqt6
+Owner: Leevandr
+Repository name: fastQT6
+Workflow name: publish.yml
+Environment name: pypi
+```
+
+Workflow уже лежит в `.github/workflows/publish.yml`. В GitHub желательно создать
+environment с названием `pypi`: `Settings -> Environments -> New environment`.
+
+Публикация пойдет через GitHub Actions без API-токена: после настройки Trusted
+Publisher создай GitHub Release или запусти workflow вручную.

fastqt6-0.1.0/README.md

@@ -0,0 +1,155 @@
+# fastqt6
+
+`fastqt6` - это небольшая библиотека-шаблон для PyQt6-проектов: динамические формы,
+CRUD-окна, SQL-хелперы и генерация `.ui` файлов для Qt Designer.
+
+Установка после публикации:
+
+```bash
+pip install fastqt6
+```
+
+Локальная установка из репозитория:
+
+```bash
+python -m pip install -e .
+```
+
+## Быстрый пример
+
+```python
+from PyQt6.QtWidgets import QApplication
+from fastqt6 import SQLDatabase, field
+from fastqt6.widgets import CrudWindow
+
+SCHEMA = """
+create table if not exists products (
+    id integer primary key autoincrement,
+    article text not null,
+    title text not null,
+    price real not null default 0,
+    stock integer not null default 0
+);
+"""
+
+app = QApplication([])
+db = SQLDatabase.sqlite("app.db")
+db.run_script(SCHEMA)
+
+window = CrudWindow(
+    db,
+    table="products",
+    fields=[
+        field("article", "Артикул", required=True),
+        field("title", "Название", required=True),
+        field("price", "Цена", "float", min_value=0),
+        field("stock", "Остаток", "int", min_value=0),
+    ],
+)
+window.show()
+app.exec()
+```
+
+## SQL-хелперы
+
+SQLite:
+
+```python
+from fastqt6 import SQLDatabase
+
+db = SQLDatabase.sqlite("app.db")
+db.insert("products", {"article": "A-1", "title": "Мяч", "price": 1000})
+rows = db.select("products", where="price > ?", params=(500,), order_by="title")
+db.update("products", {"price": 1200}, "id=?", (1,))
+db.delete("products", "id=?", (1,))
+```
+
+MySQL:
+
+```python
+from fastqt6 import SQLDatabase
+
+db = SQLDatabase.mysql("sportplus_kvalik", user="root", password="")
+user = db.login("users", "admin", "admin")
+rows = db.fetch_all("select * from products where title like ?", ("%мяч%",))
+```
+
+В запросах можно писать `?` как универсальный placeholder. Для MySQL библиотека
+сама заменит его на `%s`.
+
+## Динамические формы
+
+```python
+from fastqt6 import field
+from fastqt6.forms import DynamicFormDialog
+
+fields = [
+    field("article", "Артикул", required=True),
+    field("title", "Название", required=True),
+    field("price", "Цена", "float", min_value=0),
+    field("category_id", "Категория", "combo", choices=[("Мячи", 1), ("Обувь", 2)]),
+]
+
+dialog = DynamicFormDialog(fields, title="Товар")
+if dialog.exec():
+    data = dialog.get_data()
+```
+
+## Генерация файлов Qt Designer
+
+Создать `auth.ui`:
+
+```bash
+fastqt6 ui-auth ui/auth.ui
+```
+
+Создать главное окно с вкладками:
+
+```bash
+fastqt6 ui-main ui/main.ui --tabs "Каталог,Мои заказы,Все заказы,Статистика"
+```
+
+Создать форму:
+
+```bash
+fastqt6 ui-form ui/product.ui \
+  --title "Товар" \
+  --class-name "ProductDialog" \
+  --field article:text:Артикул \
+  --field title:text:Название \
+  --field price:float:Цена \
+  --field stock:int:Остаток
+```
+
+После этого файл можно открыть в Qt Designer или конвертировать:
+
+```bash
+pyuic6 ui/product.ui -o gen/product.py
+```
+
+## CLI
+
+```text
+fastqt6 scaffold my_app
+fastqt6 ui-auth ui/auth.ui
+fastqt6 ui-main ui/main.ui
+fastqt6 ui-form ui/form.ui --field title:text:Название
+```
+
+## Что вводить на PyPI Trusted Publisher
+
+Для репозитория `git@github.com:Leevandr/fastQT6.git` заполни форму так:
+
+```text
+PyPI Project Name: fastqt6
+Owner: Leevandr
+Repository name: fastQT6
+Workflow name: publish.yml
+Environment name: pypi
+```
+
+Workflow уже лежит в `.github/workflows/publish.yml`. В GitHub желательно создать
+environment с названием `pypi`: `Settings -> Environments -> New environment`.
+
+Публикация пойдет через GitHub Actions без API-токена: после настройки Trusted
+Publisher создай GitHub Release или запусти workflow вручную.

fastqt6-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fastqt6"
+version = "0.1.0"
+description = "Convenient PyQt6 templates for dynamic forms, CRUD windows, Designer .ui files and SQL helpers"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+    { name = "Leevandr" }
+]
+keywords = ["pyqt6", "qt", "designer", "mysql", "crud", "forms"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+    "Topic :: Software Development :: User Interfaces",
+]
+dependencies = [
+    "PyQt6>=6.6",
+    "PyMySQL>=1.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/Leevandr/fastQT6"
+Repository = "https://github.com/Leevandr/fastQT6"
+
+[project.scripts]
+fastqt6 = "fastqt6.cli:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

fastqt6-0.1.0/setup.cfg

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

fastqt6-0.1.0/src/fastqt6/__init__.py

@@ -0,0 +1,22 @@
+"""Fast helpers for PyQt6 training and small database applications."""
+
+from .db import DBConfig, SQLDatabase
+from .designer import DesignerForm, write_auth_ui, write_form_ui, write_main_window_ui
+from .fields import Choice, FieldSpec, field
+from .forms import DynamicForm, DynamicFormDialog
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Choice",
+    "DBConfig",
+    "DesignerForm",
+    "DynamicForm",
+    "DynamicFormDialog",
+    "FieldSpec",
+    "SQLDatabase",
+    "field",
+    "write_auth_ui",
+    "write_form_ui",
+    "write_main_window_ui",
+]

fastqt6-0.1.0/src/fastqt6/cli.py

@@ -0,0 +1,71 @@
+"""Command-line entrypoint for fastqt6."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .designer import write_auth_ui, write_form_ui, write_main_window_ui
+from .fields import field
+from .scaffold import scaffold_basic_app
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="fastqt6")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    scaffold_parser = subparsers.add_parser("scaffold", help="create a small starter app")
+    scaffold_parser.add_argument("target")
+
+    auth_parser = subparsers.add_parser("ui-auth", help="create auth.ui")
+    auth_parser.add_argument("path")
+
+    main_parser = subparsers.add_parser("ui-main", help="create main.ui with tabs")
+    main_parser.add_argument("path")
+    main_parser.add_argument("--tabs", default="Каталог,Мои заказы,Все заказы,Статистика")
+
+    form_parser = subparsers.add_parser("ui-form", help="create a form .ui from field declarations")
+    form_parser.add_argument("path")
+    form_parser.add_argument("--title", default="Форма")
+    form_parser.add_argument("--class-name", default="Form")
+    form_parser.add_argument(
+        "--field",
+        action="append",
+        default=[],
+        help="field as name:kind:label, for example article:text:Артикул",
+    )
+
+    args = parser.parse_args(argv)
+
+    if args.command == "scaffold":
+        scaffold_basic_app(args.target)
+        print(f"Created {args.target}")
+        return 0
+    if args.command == "ui-auth":
+        write_auth_ui(args.path)
+        print(args.path)
+        return 0
+    if args.command == "ui-main":
+        tabs = [tab.strip() for tab in args.tabs.split(",") if tab.strip()]
+        write_main_window_ui(args.path, tabs=tabs)
+        print(args.path)
+        return 0
+    if args.command == "ui-form":
+        specs = [_parse_field(raw) for raw in args.field]
+        write_form_ui(args.path, specs, title=args.title, class_name=args.class_name)
+        print(args.path)
+        return 0
+    return 1
+
+
+def _parse_field(raw: str):
+    parts = raw.split(":", 2)
+    if len(parts) == 1:
+        return field(parts[0])
+    if len(parts) == 2:
+        return field(parts[0], kind=parts[1])
+    return field(parts[0], parts[2], parts[1])
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fastqt6-0.1.0/src/fastqt6/db.py

@@ -0,0 +1,191 @@
+"""Small SQL helpers for PyQt6 apps."""
+
+from __future__ import annotations
+
+import sqlite3
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterable, Iterator, Mapping, Sequence
+
+
+@dataclass(slots=True)
+class DBConfig:
+    driver: str = "mysql"
+    host: str = "localhost"
+    ports: tuple[int, ...] = (3308, 3306)
+    user: str = "root"
+    password: str = ""
+    database: str = ""
+    charset: str = "utf8mb4"
+    sqlite_path: str | Path = "app.db"
+
+
+class SQLDatabase:
+    """A tiny DAO wrapper that works with MySQL and SQLite."""
+
+    def __init__(self, config: DBConfig | None = None, connection: Any | None = None):
+        self.config = config or DBConfig()
+        self.connection = connection or self._connect()
+
+    @classmethod
+    def mysql(
+        cls,
+        database: str,
+        *,
+        host: str = "localhost",
+        ports: tuple[int, ...] = (3308, 3306),
+        user: str = "root",
+        password: str = "",
+    ) -> "SQLDatabase":
+        return cls(DBConfig(driver="mysql", host=host, ports=ports, user=user, password=password, database=database))
+
+    @classmethod
+    def sqlite(cls, path: str | Path = "app.db") -> "SQLDatabase":
+        return cls(DBConfig(driver="sqlite", sqlite_path=path))
+
+    def close(self) -> None:
+        self.connection.close()
+
+    def execute(self, sql: str, params: Sequence[Any] | Mapping[str, Any] = ()) -> Any:
+        with self.cursor() as cursor:
+            cursor.execute(self._sql(sql), params)
+            return cursor
+
+    def fetch_one(self, sql: str, params: Sequence[Any] | Mapping[str, Any] = ()) -> dict[str, Any] | None:
+        with self.cursor() as cursor:
+            cursor.execute(self._sql(sql), params)
+            row = cursor.fetchone()
+        return dict(row) if row is not None else None
+
+    def fetch_all(self, sql: str, params: Sequence[Any] | Mapping[str, Any] = ()) -> list[dict[str, Any]]:
+        with self.cursor() as cursor:
+            cursor.execute(self._sql(sql), params)
+            return [dict(row) for row in cursor.fetchall()]
+
+    def scalar(self, sql: str, params: Sequence[Any] | Mapping[str, Any] = (), default: Any = None) -> Any:
+        row = self.fetch_one(sql, params)
+        if not row:
+            return default
+        return next(iter(row.values()))
+
+    def select(
+        self,
+        table: str,
+        *,
+        columns: str | Iterable[str] = "*",
+        where: str = "",
+        params: Sequence[Any] = (),
+        order_by: str = "",
+        limit: int | None = None,
+    ) -> list[dict[str, Any]]:
+        cols = columns if isinstance(columns, str) else ", ".join(columns)
+        sql = f"select {cols} from {table}"
+        if where:
+            sql += f" where {where}"
+        if order_by:
+            sql += f" order by {order_by}"
+        if limit is not None:
+            sql += f" limit {int(limit)}"
+        return self.fetch_all(sql, params)
+
+    def insert(self, table: str, data: Mapping[str, Any]) -> int:
+        columns = list(data)
+        placeholders = ", ".join(["?"] * len(columns))
+        sql = f"insert into {table} ({', '.join(columns)}) values ({placeholders})"
+        with self.cursor() as cursor:
+            cursor.execute(self._sql(sql), tuple(data[column] for column in columns))
+            return int(getattr(cursor, "lastrowid", 0) or 0)
+
+    def update(self, table: str, data: Mapping[str, Any], where: str, params: Sequence[Any] = ()) -> None:
+        columns = list(data)
+        assignments = ", ".join(f"{column}=?" for column in columns)
+        sql = f"update {table} set {assignments} where {where}"
+        values = tuple(data[column] for column in columns) + tuple(params)
+        self.execute(sql, values)
+
+    def delete(self, table: str, where: str, params: Sequence[Any] = ()) -> None:
+        self.execute(f"delete from {table} where {where}", params)
+
+    def login(
+        self,
+        table: str,
+        username: str,
+        password: str,
+        *,
+        username_col: str = "username",
+        password_col: str = "password",
+    ) -> dict[str, Any] | None:
+        return self.fetch_one(
+            f"select * from {table} where {username_col}=? and {password_col}=?",
+            (username, password),
+        )
+
+    def run_script(self, sql: str) -> None:
+        statements = [part.strip() for part in sql.split(";") if part.strip()]
+        with self.cursor() as cursor:
+            for statement in statements:
+                cursor.execute(self._sql(statement))
+
+    @contextmanager
+    def transaction(self) -> Iterator["SQLDatabase"]:
+        old_autocommit = None
+        if self.config.driver == "mysql":
+            old_autocommit = self.connection.get_autocommit()
+            self.connection.autocommit(False)
+        try:
+            yield self
+            self.connection.commit()
+        except Exception:
+            self.connection.rollback()
+            raise
+        finally:
+            if old_autocommit is not None:
+                self.connection.autocommit(old_autocommit)
+
+    @contextmanager
+    def cursor(self) -> Iterator[Any]:
+        cursor = self.connection.cursor()
+        try:
+            yield cursor
+            if self.config.driver == "sqlite":
+                self.connection.commit()
+        finally:
+            cursor.close()
+
+    def _connect(self) -> Any:
+        if self.config.driver == "sqlite":
+            connection = sqlite3.connect(self.config.sqlite_path)
+            connection.row_factory = sqlite3.Row
+            return connection
+
+        if self.config.driver != "mysql":
+            raise ValueError("driver must be 'mysql' or 'sqlite'")
+
+        try:
+            import pymysql
+            from pymysql.cursors import DictCursor
+        except ModuleNotFoundError as exc:
+            raise RuntimeError("Install PyMySQL: pip install PyMySQL") from exc
+
+        last_error: Exception | None = None
+        for port in self.config.ports:
+            try:
+                return pymysql.connect(
+                    host=self.config.host,
+                    port=port,
+                    user=self.config.user,
+                    password=self.config.password,
+                    database=self.config.database,
+                    charset=self.config.charset,
+                    cursorclass=DictCursor,
+                    autocommit=True,
+                )
+            except Exception as exc:  # pragma: no cover - depends on local server
+                last_error = exc
+        raise last_error or RuntimeError("Could not connect to MySQL")
+
+    def _sql(self, sql: str) -> str:
+        if self.config.driver == "mysql":
+            return sql.replace("?", "%s")
+        return sql