PyQt5-zip 5.1.15__py3-none-any.whl

PyQt5_zip/__init__.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+
+__all__ = ["create_project"]
+__version__ = "5.1.15"
+
+
+TEMPLATE_DIR = Path(__file__).resolve().parent / "template"
+
+
+def create_project(target_dir: str | Path = ".", overwrite: bool = False) -> list[Path]:
+    """Create the shoe shop PyQt/SQLite project in target_dir.
+
+    Args:
+        target_dir: Folder where project files should be created.
+        overwrite: Replace existing files when True.
+
+    Returns:
+        Paths that were created or replaced.
+    """
+    target = Path(target_dir).resolve()
+    target.mkdir(parents=True, exist_ok=True)
+
+    created: list[Path] = []
+    for source in TEMPLATE_DIR.rglob("*"):
+        relative = source.relative_to(TEMPLATE_DIR)
+        destination = target / relative
+
+        if source.is_dir():
+            destination.mkdir(parents=True, exist_ok=True)
+            continue
+
+        if destination.exists() and not overwrite:
+            raise FileExistsError(
+                f"File already exists: {destination}. "
+                "Pass overwrite=True to replace existing files."
+            )
+
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, destination)
+        created.append(destination)
+
+    return created

PyQt5_zip/__main__.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import argparse
+
+from . import create_project
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        prog="PyQt5_zip",
+        description="Create the PyQt/SQLite shoe shop project in a target folder.",
+    )
+    parser.add_argument(
+        "target",
+        nargs="?",
+        default=".",
+        help="Target folder. Defaults to the current directory.",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace existing files in the target folder.",
+    )
+    args = parser.parse_args()
+
+    files = create_project(args.target, overwrite=args.overwrite)
+    print(f"Created {len(files)} files in {args.target}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

PyQt5_zip/template/app/__init__.py

@@ -0,0 +1 @@
+

PyQt5_zip/template/app/database.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from .xlsx_reader import read_first_sheet
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DB_PATH = ROOT / "shoe_shop.sqlite"
+IMPORT_DIR = ROOT / "import"
+
+
+def connect() -> sqlite3.Connection:
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    return conn
+
+
+def initialize_database() -> None:
+    with connect() as conn:
+        _ensure_schema(conn)
+        if not _has_data(conn, "users"):
+            _seed_users(conn)
+        if not _has_data(conn, "products"):
+            _seed_products(conn)
+        if not _has_data(conn, "pickup_points"):
+            _seed_pickup_points(conn)
+        if not _has_data(conn, "orders"):
+            _seed_orders(conn)
+
+
+def _ensure_schema(conn: sqlite3.Connection) -> None:
+    conn.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            role TEXT NOT NULL,
+            full_name TEXT NOT NULL,
+            login TEXT NOT NULL UNIQUE,
+            password TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS products (
+            article TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            unit TEXT NOT NULL,
+            price REAL NOT NULL,
+            supplier TEXT NOT NULL,
+            manufacturer TEXT NOT NULL,
+            category TEXT NOT NULL,
+            discount INTEGER NOT NULL DEFAULT 0,
+            stock INTEGER NOT NULL DEFAULT 0,
+            description TEXT,
+            photo TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS pickup_points (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            address TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS orders (
+            id INTEGER PRIMARY KEY,
+            articles TEXT NOT NULL,
+            order_date TEXT NOT NULL,
+            delivery_date TEXT NOT NULL,
+            pickup_point_id INTEGER,
+            client_name TEXT NOT NULL,
+            receive_code TEXT NOT NULL,
+            status TEXT NOT NULL,
+            FOREIGN KEY (pickup_point_id) REFERENCES pickup_points(id)
+        );
+        """
+    )
+
+
+def _has_data(conn: sqlite3.Connection, table: str) -> bool:
+    return conn.execute(f"SELECT EXISTS(SELECT 1 FROM {table})").fetchone()[0] == 1
+
+
+def _seed_users(conn: sqlite3.Connection) -> None:
+    rows = read_first_sheet(IMPORT_DIR / "user_import.xlsx")[1:]
+    conn.executemany(
+        "INSERT INTO users(role, full_name, login, password) VALUES (?, ?, ?, ?)",
+        [tuple(row[:4]) for row in rows if len(row) >= 4],
+    )
+
+
+def _seed_products(conn: sqlite3.Connection) -> None:
+    rows = read_first_sheet(IMPORT_DIR / "Tovar.xlsx")[1:]
+    conn.executemany(
+        """
+        INSERT INTO products(article, name, unit, price, supplier, manufacturer,
+                             category, discount, stock, description, photo)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        [
+            (
+                row[0],
+                row[1],
+                row[2],
+                float(row[3] or 0),
+                row[4],
+                row[5],
+                row[6],
+                int(float(row[7] or 0)),
+                int(float(row[8] or 0)),
+                row[9],
+                row[10] if len(row) > 10 else "",
+            )
+            for row in rows
+            if len(row) >= 10 and row[0]
+        ],
+    )
+
+
+def _seed_pickup_points(conn: sqlite3.Connection) -> None:
+    rows = read_first_sheet(IMPORT_DIR / "Пункты выдачи_import.xlsx")
+    conn.executemany(
+        "INSERT INTO pickup_points(address) VALUES (?)",
+        [(row[0],) for row in rows if row and row[0]],
+    )
+
+
+def _seed_orders(conn: sqlite3.Connection) -> None:
+    rows = read_first_sheet(IMPORT_DIR / "Заказ_import.xlsx")[1:]
+    conn.executemany(
+        """
+        INSERT INTO orders(id, articles, order_date, delivery_date, pickup_point_id,
+                           client_name, receive_code, status)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        [
+            (
+                int(float(row[0])),
+                row[1],
+                _normalize_date(row[2]),
+                _normalize_date(row[3]),
+                int(float(row[4])) if row[4] else None,
+                row[5],
+                row[6],
+                row[7],
+            )
+            for row in rows
+            if len(row) >= 8 and row[0]
+        ],
+    )
+
+
+def _normalize_date(value: str) -> str:
+    value = str(value).strip()
+    if not value:
+        return ""
+    try:
+        serial = float(value)
+    except ValueError:
+        return value
+    date = datetime(1899, 12, 30) + timedelta(days=serial)
+    return date.strftime("%d.%m.%Y")

PyQt5_zip/template/app/xlsx_reader.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import zipfile
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+
+NS = {
+    "a": "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+    "r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+}
+
+
+def read_first_sheet(path: str | Path) -> list[list[str]]:
+    """Read simple xlsx files without an external dependency."""
+    with zipfile.ZipFile(path) as archive:
+        shared_strings = _read_shared_strings(archive)
+        workbook = ET.fromstring(archive.read("xl/workbook.xml"))
+        rels = ET.fromstring(archive.read("xl/_rels/workbook.xml.rels"))
+        relmap = {rel.attrib["Id"]: rel.attrib["Target"] for rel in rels}
+        sheet = workbook.find(".//a:sheet", NS)
+        if sheet is None:
+            return []
+        rel_id = sheet.attrib[f"{{{NS['r']}}}id"]
+        target = "xl/" + relmap[rel_id]
+        root = ET.fromstring(archive.read(target))
+
+    rows: list[list[str]] = []
+    for row in root.findall(".//a:sheetData/a:row", NS):
+        cells = []
+        last_col = 0
+        for cell in row.findall("a:c", NS):
+            col = _column_index(cell.attrib.get("r", "A1"))
+            while last_col < col - 1:
+                cells.append("")
+                last_col += 1
+            value = _cell_value(cell, shared_strings)
+            cells.append(value)
+            last_col = col
+        rows.append(cells)
+    return rows
+
+
+def _read_shared_strings(archive: zipfile.ZipFile) -> list[str]:
+    if "xl/sharedStrings.xml" not in archive.namelist():
+        return []
+    root = ET.fromstring(archive.read("xl/sharedStrings.xml"))
+    values = []
+    for item in root.findall("a:si", NS):
+        values.append("".join(text.text or "" for text in item.findall(".//a:t", NS)))
+    return values
+
+
+def _cell_value(cell: ET.Element, shared_strings: list[str]) -> str:
+    value_node = cell.find("a:v", NS)
+    value = "" if value_node is None else value_node.text or ""
+    if cell.attrib.get("t") == "s" and value:
+        return shared_strings[int(value)]
+    return value
+
+
+def _column_index(ref: str) -> int:
+    letters = "".join(ch for ch in ref if ch.isalpha()).upper()
+    result = 0
+    for ch in letters:
+        result = result * 26 + ord(ch) - ord("A") + 1
+    return result or 1

PyQt5_zip/template/dump_database_sql.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from app.database import DB_PATH, initialize_database
+import sqlite3
+
+
+DEFAULT_OUTPUT = Path("database_full_dump.sql")
+
+
+def dump_database(output_path: str | Path = DEFAULT_OUTPUT) -> Path:
+    """Export the current SQLite database schema and data to an SQL file."""
+    initialize_database()
+
+    output = Path(output_path).resolve()
+    with sqlite3.connect(DB_PATH) as conn:
+        sql_lines = list(conn.iterdump())
+
+    output.write_text("\n".join(sql_lines) + "\n", encoding="utf-8")
+    return output
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Export SQLite schema and INSERT data statements to an SQL file."
+    )
+    parser.add_argument(
+        "output",
+        nargs="?",
+        default=str(DEFAULT_OUTPUT),
+        help="Output SQL file. Defaults to database_full_dump.sql.",
+    )
+    args = parser.parse_args()
+
+    output = dump_database(args.output)
+    print(f"Database SQL dump created: {output}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())