deskkit 1.1.0__py3-none-any.whl

deskkit/__init__.py

@@ -0,0 +1,44 @@
+"""DeskKit — простые десктоп-приложения на Qt и MySQL."""
+
+from deskkit.app import ShopApp, run_app, run_from_json
+from deskkit.auth import AuthService, make_guest, user_display_name
+from deskkit.catalog import apply_catalog_filters, search_products, sort_products
+from deskkit.config import AppConfig
+from deskkit.database import Database
+from deskkit.exceptions import AuthError, DatabaseError, DeskKitError, ValidationError
+from deskkit.generator import export_project, run_generated
+from deskkit.images import load_pixmap, save_product_image, validate_product_data
+from deskkit.qt_backend import backend_name, init_qt
+from deskkit.roles import ADMIN, CLIENT, GUEST, MANAGER
+
+__version__ = "1.1.0"
+
+__all__ = [
+    "ShopApp",
+    "AppConfig",
+    "Database",
+    "AuthService",
+    "export_project",
+    "run_generated",
+    "run_app",
+    "run_from_json",
+    "apply_catalog_filters",
+    "search_products",
+    "sort_products",
+    "load_pixmap",
+    "save_product_image",
+    "validate_product_data",
+    "make_guest",
+    "user_display_name",
+    "init_qt",
+    "backend_name",
+    "ADMIN",
+    "CLIENT",
+    "GUEST",
+    "MANAGER",
+    "DeskKitError",
+    "DatabaseError",
+    "AuthError",
+    "ValidationError",
+    "__version__",
+]

deskkit/app.py

@@ -0,0 +1,114 @@
+"""Точка входа — запуск готового приложения."""
+
+from __future__ import annotations
+
+import sys
+from typing import Callable
+
+from deskkit import qt_backend
+from deskkit.auth import AuthService
+from deskkit.config import AppConfig
+from deskkit.database import Database
+from deskkit.exceptions import DatabaseError
+from deskkit.images import ensure_images_dir
+from deskkit.ui.login_window import LoginWindow
+from deskkit.ui.main_window import MainWindow
+from deskkit.ui.styles import APP_STYLE
+
+qt_backend.init_qt()
+QtWidgets = qt_backend.QtWidgets
+
+
+class ShopApp:
+    """
+    Готовое приложение «из коробки».
+
+    Пример:
+        from deskkit import ShopApp, AppConfig
+
+        ShopApp(AppConfig(
+            title="Обувной магазин",
+            database="shoe_store",
+            password="root",
+        )).run()
+    """
+
+    def __init__(self, config: AppConfig | None = None):
+        self.config = config or AppConfig()
+        qt_backend.init_qt(self.config.qt_backend)
+        self.db = Database(self.config)
+        self.auth = AuthService(self.db)
+        self._app: QtWidgets.QApplication | None = None
+        self._main_window: MainWindow | None = None
+
+    def run(self) -> int:
+        """Запустить приложение или сгенерировать автономный проект."""
+        if self.config.export_project and not self.config.library_runtime:
+            from deskkit.generator import export_project, run_generated
+
+            out = export_project(self.config)
+            print(f"Проект создан: {out}")
+            if self.config.run_generated:
+                return run_generated(self.config, out)
+            return 0
+
+        return self._run_library()
+
+    def _run_library(self) -> int:
+        """Запуск через deskkit (режим разработки)."""
+        ensure_images_dir(self.config)
+
+        self._app = QtWidgets.QApplication.instance()
+        if self._app is None:
+            self._app = QtWidgets.QApplication(sys.argv)
+        self._app.setStyleSheet(APP_STYLE)
+
+        try:
+            if not self.db.test_connection():
+                QtWidgets.QMessageBox.critical(
+                    None,
+                    "Ошибка подключения",
+                    "Не удалось подключиться к базе данных.\n"
+                    "Проверьте настройки AppConfig.",
+                )
+                return 1
+        except DatabaseError as exc:
+            QtWidgets.QMessageBox.critical(None, "Ошибка подключения", str(exc))
+            return 1
+
+        if not self._show_login():
+            return 0
+        return qt_backend.exec_app(self._app)
+
+    def _show_login(self) -> bool:
+        def on_success(user: dict) -> None:
+            self._show_main()
+
+        login = LoginWindow(self.config, self.auth, on_success)
+        result = login.exec()
+        return result == QtWidgets.QDialog.DialogCode.Accepted
+
+    def _show_main(self) -> None:
+        if self._main_window:
+            self._main_window.close()
+
+        def on_logout() -> None:
+            self._show_login()
+
+        self._main_window = MainWindow(
+            self.config,
+            self.db,
+            self.auth,
+            on_logout=on_logout,
+        )
+        self._main_window.show()
+
+
+def run_app(config: AppConfig | None = None) -> int:
+    """Быстрый запуск приложения одной функцией."""
+    return ShopApp(config).run()
+
+
+def run_from_json(path: str) -> int:
+    """Запуск по JSON-файлу настроек."""
+    return ShopApp(AppConfig.from_json(path)).run()

deskkit/auth.py

@@ -0,0 +1,72 @@
+"""Авторизация пользователей."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from deskkit.database import Database
+from deskkit.exceptions import AuthError
+from deskkit.roles import ADMIN, CLIENT, GUEST, MANAGER
+
+
+def make_guest() -> dict[str, Any]:
+    return {
+        "id_user": 0,
+        "login": "guest",
+        "first_name": "Гость",
+        "last_name": "",
+        "middle_name": None,
+        "id_role": 0,
+        "role_name": GUEST,
+    }
+
+
+def user_display_name(user: dict[str, Any]) -> str:
+    parts = [user.get("last_name", ""), user.get("first_name", "")]
+    middle = user.get("middle_name")
+    if middle:
+        parts.append(middle)
+    name = " ".join(p for p in parts if p).strip()
+    return name or user.get("login", "Пользователь")
+
+
+class AuthService:
+    def __init__(self, db: Database):
+        self.db = db
+        self.current_user: dict[str, Any] | None = None
+
+    @property
+    def role(self) -> str:
+        if not self.current_user:
+            return GUEST
+        return str(self.current_user.get("role_name", GUEST))
+
+    def login(self, login: str, password: str) -> dict[str, Any]:
+        if not login.strip() or not password.strip():
+            raise AuthError("Введите логин и пароль")
+
+        user = self.db.authenticate(login.strip(), password)
+        if not user:
+            raise AuthError("Неверный логин или пароль")
+
+        self.current_user = user
+        return user
+
+    def login_as_guest(self) -> dict[str, Any]:
+        self.current_user = make_guest()
+        return self.current_user
+
+    def logout(self) -> None:
+        self.current_user = None
+
+    def is_admin(self) -> bool:
+        return self.role == ADMIN
+
+    def is_manager(self) -> bool:
+        return self.role == MANAGER
+
+    def is_client(self) -> bool:
+        return self.role == CLIENT
+
+    def is_guest(self) -> bool:
+        return self.role == GUEST

deskkit/catalog.py

@@ -0,0 +1,103 @@
+"""Поиск, фильтрация и сортировка товаров."""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+
+def _text(value: Any) -> str:
+    if value is None:
+        return ""
+    return str(value).lower()
+
+
+def search_products(
+    products: list[dict[str, Any]],
+    query: str,
+    fields: list[str] | None = None,
+) -> list[dict[str, Any]]:
+    """Поиск в реальном времени по текстовым полям."""
+    if not query.strip():
+        return list(products)
+
+    q = query.strip().lower()
+    if fields is None:
+        fields = [
+            "article_number",
+            "product_name",
+            "description",
+            "category_name",
+            "manufacturer_name",
+            "supplier_name",
+            "unit",
+            "availability_status",
+        ]
+
+    result = []
+    for product in products:
+        for field in fields:
+            if q in _text(product.get(field)):
+                result.append(product)
+                break
+    return result
+
+
+def filter_by_supplier(
+    products: list[dict[str, Any]],
+    supplier_id: int | None,
+) -> list[dict[str, Any]]:
+    if supplier_id is None or supplier_id <= 0:
+        return list(products)
+    return [p for p in products if int(p.get("id_supplier") or 0) == supplier_id]
+
+
+def filter_by_category(
+    products: list[dict[str, Any]],
+    category_id: int | None,
+) -> list[dict[str, Any]]:
+    if category_id is None or category_id <= 0:
+        return list(products)
+    return [p for p in products if int(p.get("id_category") or 0) == category_id]
+
+
+def sort_products(
+    products: list[dict[str, Any]],
+    field: str = "stock_quantity",
+    ascending: bool = True,
+) -> list[dict[str, Any]]:
+    def key_fn(item: dict[str, Any]) -> Any:
+        value = item.get(field, 0)
+        if value is None:
+            return 0
+        return value
+
+    return sorted(products, key=key_fn, reverse=not ascending)
+
+
+def apply_catalog_filters(
+    products: list[dict[str, Any]],
+    *,
+    search: str = "",
+    supplier_id: int | None = None,
+    category_id: int | None = None,
+    sort_field: str = "product_name",
+    sort_asc: bool = True,
+) -> list[dict[str, Any]]:
+    """Комбинирует поиск, фильтры и сортировку."""
+    result = search_products(products, search)
+    result = filter_by_supplier(result, supplier_id)
+    result = filter_by_category(result, category_id)
+    return sort_products(result, sort_field, sort_asc)
+
+
+def row_style(product: dict[str, Any], rules: list[dict[str, Any]]) -> dict[str, str]:
+    """Возвращает стили строки по правилам условного форматирования."""
+    styles: dict[str, str] = {}
+    for rule in rules:
+        condition: Callable[[dict[str, Any]], bool] = rule["when"]
+        if condition(product):
+            if "background" in rule:
+                styles["background"] = rule["background"]
+            if "foreground" in rule:
+                styles["foreground"] = rule["foreground"]
+    return styles

deskkit/config.py

@@ -0,0 +1,130 @@
+"""Конфигурация приложения."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class AppConfig:
+    """Настройки приложения — достаточно заполнить и передать в ShopApp."""
+
+    title: str = "Каталог товаров"
+    host: str = "localhost"
+    port: int = 3306
+    user: str = "root"
+    password: str = ""
+    database: str = "shoe_store"
+
+    images_dir: str = "images"
+    placeholder_image: str = "picture.png"
+
+    qt_backend: str | None = None  # 'pyside6' | 'pyqt6' | None
+
+    # Поля каталога (9 полей для отображения)
+    catalog_columns: list[str] = field(
+        default_factory=lambda: [
+            "photo",
+            "article_number",
+            "product_name",
+            "category_name",
+            "manufacturer_name",
+            "supplier_name",
+            "price",
+            "unit",
+            "stock_quantity",
+            "discount_percent",
+        ]
+    )
+
+    column_labels: dict[str, str] = field(
+        default_factory=lambda: {
+            "photo": "Фото",
+            "article_number": "Артикул",
+            "product_name": "Наименование",
+            "category_name": "Категория",
+            "manufacturer_name": "Производитель",
+            "supplier_name": "Поставщик",
+            "price": "Цена",
+            "unit": "Ед. изм.",
+            "stock_quantity": "Кол-во",
+            "discount_percent": "Скидка %",
+            "description": "Описание",
+            "availability_status": "Наличие",
+        }
+    )
+
+    # Условное форматирование строк каталога
+    format_rules: list[dict[str, Any]] = field(
+        default_factory=lambda: [
+            {
+                "name": "discount",
+                "when": lambda p: float(p.get("discount_percent") or 0) > 0,
+                "background": "#FFF5F5",
+            },
+            {
+                "name": "out_of_stock",
+                "when": lambda p: int(p.get("stock_quantity") or 0) == 0,
+                "background": "#ECECEC",
+                "foreground": "#888888",
+            },
+            {
+                "name": "big_discount",
+                "when": lambda p: float(p.get("discount_percent") or 0) >= 15,
+                "background": "#E8F5E9",
+                "foreground": "#2E8B57",
+            },
+        ]
+    )
+
+    image_width: int = 300
+    image_height: int = 200
+
+    # --- Экспорт автономного проекта (по умолчанию включён) ---
+    export_project: bool = True
+    """True: сгенерировать готовый проект без импортов deskkit."""
+    output_dir: str = ""
+    """Папка результата. Пусто — имя из title."""
+    project_name: str = ""
+    """Имя папки проекта (slug)."""
+    include_seed_data: bool = True
+    """Добавить тестовые данные в sql/database.sql."""
+    run_generated: bool = True
+    """После генерации запустить main.py сгенерированного проекта."""
+    library_runtime: bool = False
+    """True: запуск через deskkit (без генерации). Приоритет над export_project."""
+
+    @classmethod
+    def from_json(cls, path: str | Path) -> "AppConfig":
+        data = json.loads(Path(path).read_text(encoding="utf-8"))
+        known = {f.name for f in cls.__dataclass_fields__.values()}  # type: ignore[attr-defined]
+        filtered = {k: v for k, v in data.items() if k in known and k not in ("format_rules",)}
+        return cls(**filtered)
+
+    def save_json(self, path: str | Path) -> None:
+        data = {
+            "title": self.title,
+            "host": self.host,
+            "port": self.port,
+            "user": self.user,
+            "password": self.password,
+            "database": self.database,
+            "images_dir": self.images_dir,
+            "placeholder_image": self.placeholder_image,
+            "qt_backend": self.qt_backend,
+            "image_width": self.image_width,
+            "image_height": self.image_height,
+            "export_project": self.export_project,
+            "output_dir": self.output_dir,
+            "project_name": self.project_name,
+            "include_seed_data": self.include_seed_data,
+            "run_generated": self.run_generated,
+            "library_runtime": self.library_runtime,
+        }
+        Path(path).write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    def images_path(self) -> Path:
+        return Path(self.images_dir)

deskkit/database.py

@@ -0,0 +1,211 @@
+"""Работа с MySQL через mysql.connector."""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from decimal import Decimal
+from typing import Any, Generator, Iterable
+
+import mysql.connector
+from mysql.connector import Error as MySQLError
+
+from deskkit.config import AppConfig
+from deskkit.exceptions import DatabaseError
+
+
+def _row_to_dict(cursor: Any, row: tuple) -> dict[str, Any]:
+    columns = [desc[0] for desc in cursor.description]
+    result: dict[str, Any] = {}
+    for key, value in zip(columns, row):
+        if isinstance(value, Decimal):
+            value = float(value)
+        result[key] = value
+    return result
+
+
+class Database:
+    """Простой слой доступа к MySQL."""
+
+    PRODUCTS_QUERY = """
+        SELECT
+            p.id_product,
+            p.article_number,
+            p.product_name,
+            p.description,
+            p.price,
+            p.discount_percent,
+            p.unit,
+            p.stock_quantity,
+            p.photo_url,
+            p.id_category,
+            p.id_supplier,
+            p.id_manufacturer,
+            c.category_name,
+            m.manufacturer_name,
+            s.supplier_name,
+            CASE
+                WHEN p.stock_quantity = 0 THEN 'Нет в наличии'
+                WHEN p.stock_quantity <= 5 THEN 'Мало в наличии'
+                ELSE 'В наличии'
+            END AS availability_status
+        FROM products p
+        LEFT JOIN categories c ON p.id_category = c.id_category
+        LEFT JOIN manufacturers m ON p.id_manufacturer = m.id_manufacturer
+        LEFT JOIN suppliers s ON p.id_supplier = s.id_supplier
+    """
+
+    def __init__(self, config: AppConfig):
+        self.config = config
+
+    def _connect(self) -> mysql.connector.MySQLConnection:
+        try:
+            return mysql.connector.connect(
+                host=self.config.host,
+                port=self.config.port,
+                user=self.config.user,
+                password=self.config.password,
+                database=self.config.database,
+                charset="utf8mb4",
+                use_unicode=True,
+            )
+        except MySQLError as exc:
+            raise DatabaseError(f"Не удалось подключиться к MySQL: {exc}") from exc
+
+    @contextmanager
+    def connection(self) -> Generator[mysql.connector.MySQLConnection, None, None]:
+        conn = self._connect()
+        try:
+            yield conn
+        finally:
+            conn.close()
+
+    @contextmanager
+    def cursor(self, dictionary: bool = False) -> Generator[Any, None, None]:
+        with self.connection() as conn:
+            cur = conn.cursor(dictionary=dictionary)
+            try:
+                yield cur
+                conn.commit()
+            except Exception:
+                conn.rollback()
+                raise
+            finally:
+                cur.close()
+
+    def test_connection(self) -> bool:
+        with self.connection() as conn:
+            return conn.is_connected()
+
+    def fetch_all(self, query: str, params: Iterable[Any] | None = None) -> list[dict[str, Any]]:
+        with self.cursor() as cur:
+            cur.execute(query, params or ())
+            rows = cur.fetchall()
+            return [_row_to_dict(cur, row) for row in rows]
+
+    def fetch_one(self, query: str, params: Iterable[Any] | None = None) -> dict[str, Any] | None:
+        rows = self.fetch_all(query, params)
+        return rows[0] if rows else None
+
+    def execute(self, query: str, params: Iterable[Any] | None = None) -> int:
+        with self.cursor() as cur:
+            cur.execute(query, params or ())
+            return cur.rowcount
+
+    # --- Пользователи ---
+
+    def authenticate(self, login: str, password: str) -> dict[str, Any] | None:
+        query = """
+            SELECT
+                u.id_user, u.login, u.first_name, u.last_name, u.middle_name,
+                r.id_role, r.role_name
+            FROM users u
+            JOIN roles r ON u.id_role = r.id_role
+            WHERE u.login = %s AND u.password_hash = %s
+        """
+        return self.fetch_one(query, (login, password))
+
+    # --- Товары ---
+
+    def get_products(self) -> list[dict[str, Any]]:
+        return self.fetch_all(self.PRODUCTS_QUERY + " ORDER BY p.product_name")
+
+    def get_product(self, product_id: int) -> dict[str, Any] | None:
+        return self.fetch_one(
+            self.PRODUCTS_QUERY + " WHERE p.id_product = %s",
+            (product_id,),
+        )
+
+    def create_product(self, data: dict[str, Any]) -> int:
+        query = """
+            INSERT INTO products (
+                article_number, product_name, description, price,
+                discount_percent, unit, stock_quantity, photo_url,
+                id_category, id_manufacturer, id_supplier
+            ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+        """
+        params = (
+            data["article_number"],
+            data["product_name"],
+            data.get("description"),
+            data["price"],
+            data.get("discount_percent", 0),
+            data.get("unit", "шт."),
+            data["stock_quantity"],
+            data.get("photo_url"),
+            data["id_category"],
+            data["id_manufacturer"],
+            data["id_supplier"],
+        )
+        with self.cursor() as cur:
+            cur.execute(query, params)
+            return int(cur.lastrowid)
+
+    def update_product(self, product_id: int, data: dict[str, Any]) -> bool:
+        query = """
+            UPDATE products SET
+                article_number = %s, product_name = %s, description = %s,
+                price = %s, discount_percent = %s, unit = %s,
+                stock_quantity = %s, photo_url = %s,
+                id_category = %s, id_manufacturer = %s, id_supplier = %s
+            WHERE id_product = %s
+        """
+        params = (
+            data["article_number"],
+            data["product_name"],
+            data.get("description"),
+            data["price"],
+            data.get("discount_percent", 0),
+            data.get("unit", "шт."),
+            data["stock_quantity"],
+            data.get("photo_url"),
+            data["id_category"],
+            data["id_manufacturer"],
+            data["id_supplier"],
+            product_id,
+        )
+        return self.execute(query, params) > 0
+
+    def delete_product(self, product_id: int) -> bool:
+        return self.execute("DELETE FROM products WHERE id_product = %s", (product_id,)) > 0
+
+    def product_in_orders(self, product_id: int) -> bool:
+        row = self.fetch_one(
+            "SELECT COUNT(*) AS cnt FROM order_items WHERE id_product = %s",
+            (product_id,),
+        )
+        return bool(row and int(row["cnt"]) > 0)
+
+    # --- Справочники ---
+
+    def get_categories(self) -> list[dict[str, Any]]:
+        return self.fetch_all("SELECT id_category, category_name FROM categories ORDER BY category_name")
+
+    def get_manufacturers(self) -> list[dict[str, Any]]:
+        return self.fetch_all(
+            "SELECT id_manufacturer, manufacturer_name FROM manufacturers ORDER BY manufacturer_name"
+        )
+
+    def get_suppliers(self) -> list[dict[str, Any]]:
+        return self.fetch_all(
+            "SELECT id_supplier, supplier_name FROM suppliers ORDER BY supplier_name"
+        )

deskkit/exceptions.py

@@ -0,0 +1,17 @@
+"""Исключения библиотеки."""
+
+
+class DeskKitError(Exception):
+    """Базовая ошибка DeskKit."""
+
+
+class DatabaseError(DeskKitError):
+    """Ошибка работы с базой данных."""
+
+
+class ValidationError(DeskKitError):
+    """Ошибка валидации данных."""
+
+
+class AuthError(DeskKitError):
+    """Ошибка авторизации."""

deskkit/generator/__init__.py

@@ -0,0 +1,3 @@
+from deskkit.generator.export import export_project, run_generated
+
+__all__ = ["export_project", "run_generated"]