sqlite-sh 0.1.0__py3-none-any.whl

sqlite_sh/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

sqlite_sh/__main__.py

@@ -0,0 +1,4 @@
+from .gui import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sqlite_sh/bootstrap.py

@@ -0,0 +1,249 @@
+import re
+import shutil
+import sqlite3
+import zipfile
+from datetime import datetime, timedelta
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+from sqlite_sh.config import ASSETS_DIR, DATA_DIR, DB_FILE, PACKAGE_DIR, SCHEMA_FILE
+
+
+IMPORT_RELATIVE_DIR = (
+    Path("Прил_ОЗ_КОД 09.02.07-2-2026")
+    / "БУ"
+    / "Модуль 1"
+    / "Прил_2_ОЗ_КОД 09.02.07-2-2026-М1"
+    / "import"
+)
+
+
+def find_source_dir():
+    candidates = [
+        PACKAGE_DIR.parent.parent / IMPORT_RELATIVE_DIR,
+        Path("/home/adwed/demo-ex") / IMPORT_RELATIVE_DIR,
+        Path.cwd().parent / IMPORT_RELATIVE_DIR,
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return candidates[0]
+
+
+SOURCE_DIR = find_source_dir()
+
+NS = {"a": "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}
+
+
+def column_index(cell_ref):
+    match = re.match(r"([A-Z]+)", cell_ref or "")
+    if not match:
+        return 0
+    value = 0
+    for char in match.group(1):
+        value = value * 26 + ord(char) - 64
+    return value - 1
+
+
+def read_shared_strings(archive):
+    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(node.text or "" for node in item.findall(".//a:t", NS)))
+    return values
+
+
+def read_cell(cell, shared_strings):
+    cell_type = cell.get("t")
+    if cell_type == "inlineStr":
+        return "".join(node.text or "" for node in cell.findall(".//a:t", NS))
+    value = cell.find("a:v", NS)
+    if value is None:
+        return None
+    raw = value.text
+    if cell_type == "s":
+        return shared_strings[int(raw)]
+    return raw
+
+
+def read_xlsx_rows(path):
+    with zipfile.ZipFile(path) as archive:
+        shared_strings = read_shared_strings(archive)
+        sheet_name = "xl/worksheets/sheet1.xml"
+        root = ET.fromstring(archive.read(sheet_name))
+        rows = []
+        for row in root.findall(".//a:sheetData/a:row", NS):
+            values = []
+            last_index = -1
+            for cell in row.findall("a:c", NS):
+                idx = column_index(cell.get("r", ""))
+                while last_index + 1 < idx:
+                    values.append(None)
+                    last_index += 1
+                values.append(read_cell(cell, shared_strings))
+                last_index = idx
+            rows.append(values)
+        return rows
+
+
+def clean(value):
+    if value is None:
+        return ""
+    return str(value).replace("\xa0", " ").strip()
+
+
+def excel_date(value):
+    text = clean(value)
+    if not text:
+        return None
+    if re.fullmatch(r"\d+(\.0)?", text):
+        serial = int(float(text))
+        return (datetime(1899, 12, 30) + timedelta(days=serial)).date().isoformat()
+    try:
+        return datetime.strptime(text, "%d.%m.%Y").date().isoformat()
+    except ValueError:
+        print(f"Warning: invalid date value '{text}', saved as NULL")
+        return None
+
+
+def scalar(conn, sql, params=()):
+    row = conn.execute(sql, params).fetchone()
+    return row[0] if row else None
+
+
+def get_or_create(conn, table, name):
+    name = clean(name)
+    conn.execute(f"INSERT OR IGNORE INTO {table}(name) VALUES (?)", (name,))
+    return scalar(conn, f"SELECT id FROM {table} WHERE name = ?", (name,))
+
+
+def copy_assets():
+    ASSETS_DIR.mkdir(exist_ok=True)
+    for source in SOURCE_DIR.iterdir():
+        if source.suffix.lower() in {".png", ".ico", ".jpg", ".jpeg"}:
+            shutil.copy2(source, ASSETS_DIR / source.name)
+
+
+def import_users(conn):
+    rows = read_xlsx_rows(SOURCE_DIR / "user_import.xlsx")
+    for row in rows[1:]:
+        if len(row) < 4 or not clean(row[0]):
+            continue
+        role_id = get_or_create(conn, "roles", row[0])
+        conn.execute(
+            "INSERT OR IGNORE INTO users(role_id, full_name, login, password) VALUES (?, ?, ?, ?)",
+            (role_id, clean(row[1]), clean(row[2]), clean(row[3])),
+        )
+
+
+def import_products(conn):
+    rows = read_xlsx_rows(SOURCE_DIR / "Tovar.xlsx")
+    for row in rows[1:]:
+        if len(row) < 10 or not clean(row[0]):
+            continue
+        unit_id = get_or_create(conn, "units", row[2])
+        supplier_id = get_or_create(conn, "suppliers", row[4])
+        manufacturer_id = get_or_create(conn, "manufacturers", row[5])
+        category_id = get_or_create(conn, "categories", row[6])
+        conn.execute(
+            """
+            INSERT OR REPLACE INTO products(
+                article, name, unit_id, price, supplier_id, manufacturer_id,
+                category_id, discount, stock, description, image_path
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                clean(row[0]),
+                clean(row[1]),
+                unit_id,
+                float(clean(row[3]) or 0),
+                supplier_id,
+                manufacturer_id,
+                category_id,
+                int(float(clean(row[7]) or 0)),
+                int(float(clean(row[8]) or 0)),
+                clean(row[9]),
+                clean(row[10]) if len(row) > 10 and clean(row[10]) else None,
+            ),
+        )
+
+
+def import_pickup_points(conn):
+    rows = read_xlsx_rows(SOURCE_DIR / "Пункты выдачи_import.xlsx")
+    for row in rows:
+        if row and clean(row[0]):
+            conn.execute("INSERT OR IGNORE INTO pickup_points(address) VALUES (?)", (clean(row[0]),))
+
+
+def parse_order_items(raw):
+    parts = [clean(part) for part in clean(raw).split(",") if clean(part)]
+    result = []
+    for index in range(0, len(parts), 2):
+        if index + 1 >= len(parts):
+            break
+        result.append((parts[index], int(float(parts[index + 1]))))
+    return result
+
+
+def import_orders(conn):
+    rows = read_xlsx_rows(SOURCE_DIR / "Заказ_import.xlsx")
+    for row in rows[1:]:
+        if len(row) < 8 or not clean(row[0]):
+            continue
+        order_id = int(float(clean(row[0])))
+        pickup_point_id = int(float(clean(row[4]))) if clean(row[4]) else None
+        conn.execute(
+            """
+            INSERT OR REPLACE INTO orders(
+                id, order_date, delivery_date, pickup_point_id, client_name, receive_code, status
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                order_id,
+                excel_date(row[2]),
+                excel_date(row[3]),
+                pickup_point_id,
+                clean(row[5]),
+                clean(row[6]),
+                clean(row[7]),
+            ),
+        )
+        conn.execute("DELETE FROM order_items WHERE order_id = ?", (order_id,))
+        for article, quantity in parse_order_items(row[1]):
+            product_id = scalar(conn, "SELECT id FROM products WHERE article = ?", (article,))
+            if product_id is None:
+                print(f"Warning: product article '{article}' not found for order {order_id}")
+                continue
+            conn.execute(
+                "INSERT INTO order_items(order_id, product_id, quantity) VALUES (?, ?, ?)",
+                (order_id, product_id, quantity),
+            )
+
+
+def reset_database():
+    DATA_DIR.mkdir(exist_ok=True)
+    if DB_FILE.exists():
+        DB_FILE.unlink()
+    with sqlite3.connect(DB_FILE) as conn:
+        conn.execute("PRAGMA foreign_keys = ON")
+        conn.executescript(SCHEMA_FILE.read_text(encoding="utf-8"))
+        import_users(conn)
+        import_products(conn)
+        import_pickup_points(conn)
+        import_orders(conn)
+        conn.commit()
+
+
+def main():
+    if not SOURCE_DIR.exists():
+        raise SystemExit(f"Source directory not found: {SOURCE_DIR}")
+    copy_assets()
+    reset_database()
+    print(f"Database created: {DB_FILE}")
+    print(f"Assets copied: {ASSETS_DIR}")
+
+
+if __name__ == "__main__":
+    main()

sqlite_sh/config.py

@@ -0,0 +1,23 @@
+import os
+import shutil
+from pathlib import Path
+
+
+PACKAGE_DIR = Path(__file__).resolve().parent
+ASSETS_DIR = PACKAGE_DIR / "assets"
+DATA_DIR = PACKAGE_DIR / "data"
+SCHEMA_FILE = PACKAGE_DIR / "database.sql"
+SEED_DB_FILE = DATA_DIR / "shop.db"
+
+USER_DIR = Path(os.environ.get("SQLITE_SH_HOME", Path.home() / ".sqlite_sh"))
+DB_FILE = USER_DIR / "shop.db"
+
+
+def ensure_user_database():
+    USER_DIR.mkdir(parents=True, exist_ok=True)
+    if not DB_FILE.exists() and SEED_DB_FILE.exists():
+        shutil.copy2(SEED_DB_FILE, DB_FILE)
+    return DB_FILE
+
+
+ensure_user_database()

sqlite_sh/database.sql

@@ -0,0 +1,87 @@
+PRAGMA foreign_keys = ON;
+
+DROP TABLE IF EXISTS order_items;
+DROP TABLE IF EXISTS orders;
+DROP TABLE IF EXISTS products;
+DROP TABLE IF EXISTS pickup_points;
+DROP TABLE IF EXISTS users;
+DROP TABLE IF EXISTS roles;
+DROP TABLE IF EXISTS categories;
+DROP TABLE IF EXISTS manufacturers;
+DROP TABLE IF EXISTS suppliers;
+DROP TABLE IF EXISTS units;
+
+CREATE TABLE roles (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL UNIQUE
+);
+
+CREATE TABLE users (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    role_id INTEGER NOT NULL REFERENCES roles(id),
+    full_name TEXT NOT NULL,
+    login TEXT NOT NULL UNIQUE,
+    password TEXT NOT NULL
+);
+
+CREATE TABLE categories (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL UNIQUE
+);
+
+CREATE TABLE manufacturers (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL UNIQUE
+);
+
+CREATE TABLE suppliers (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL UNIQUE
+);
+
+CREATE TABLE units (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL UNIQUE
+);
+
+CREATE TABLE products (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    article TEXT NOT NULL UNIQUE,
+    name TEXT NOT NULL,
+    unit_id INTEGER NOT NULL REFERENCES units(id),
+    price REAL NOT NULL CHECK (price >= 0),
+    supplier_id INTEGER NOT NULL REFERENCES suppliers(id),
+    manufacturer_id INTEGER NOT NULL REFERENCES manufacturers(id),
+    category_id INTEGER NOT NULL REFERENCES categories(id),
+    discount INTEGER NOT NULL DEFAULT 0 CHECK (discount >= 0),
+    stock INTEGER NOT NULL DEFAULT 0 CHECK (stock >= 0),
+    description TEXT NOT NULL DEFAULT '',
+    image_path TEXT
+);
+
+CREATE TABLE pickup_points (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    address TEXT NOT NULL UNIQUE
+);
+
+CREATE TABLE orders (
+    id INTEGER PRIMARY KEY,
+    order_date TEXT,
+    delivery_date TEXT,
+    pickup_point_id INTEGER REFERENCES pickup_points(id),
+    client_name TEXT,
+    receive_code TEXT,
+    status TEXT NOT NULL
+);
+
+CREATE TABLE order_items (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    order_id INTEGER NOT NULL REFERENCES orders(id) ON DELETE CASCADE,
+    product_id INTEGER NOT NULL REFERENCES products(id),
+    quantity INTEGER NOT NULL CHECK (quantity > 0),
+    UNIQUE(order_id, product_id)
+);
+
+CREATE INDEX idx_products_article ON products(article);
+CREATE INDEX idx_products_supplier ON products(supplier_id);
+CREATE INDEX idx_order_items_product ON order_items(product_id);

sqlite_sh/diagram.py

@@ -0,0 +1,37 @@
+import sqlite3
+
+from sqlite_sh.config import DB_FILE
+
+
+def main():
+    if not DB_FILE.exists():
+        raise SystemExit("База данных не найдена. Сначала выполните: python bootstrap_db.py")
+
+    with sqlite3.connect(DB_FILE) as conn:
+        tables = [
+            row[0]
+            for row in conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+            )
+        ]
+
+        print("erDiagram")
+        for table in tables:
+            print(f"    {table} {{")
+            for col in conn.execute(f"PRAGMA table_info({table})"):
+                col_name = col[1]
+                col_type = col[2] or "TEXT"
+                pk = " PK" if col[5] else ""
+                print(f"        {col_type} {col_name}{pk}")
+            print("    }")
+
+        for table in tables:
+            for fk in conn.execute(f"PRAGMA foreign_key_list({table})"):
+                ref_table = fk[2]
+                from_col = fk[3]
+                to_col = fk[4]
+                print(f"    {ref_table} ||--o{{ {table} : \"{to_col} to {from_col}\"")
+
+
+if __name__ == "__main__":
+    main()