Replace python-qbittorrent with qbittorrent-api

requirements.txt

@@ -1 +1,2 @@
-python-qbittorrent==0.4.3
+qbittorrent-api==2025.2.0
+SQLAlchemy==2.0.38

tarc/main.py

@@ -13,145 +13,81 @@ import sys
 import re
 import uuid
 import argparse
-import sqlite3
-
 from datetime import datetime, timezone
 
-import qbittorrent
+import qbittorrentapi
+from sqlalchemy import create_engine, inspect
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import DatabaseError
+
+from .models import Base, SchemaVersion, Client
 
 # SCHEMA format is YYYYMMDDX
-SCHEMA = 202410060
+SCHEMA = 202503100
 
 
-def init_db(conn):
+def init_db(engine):
     """
     Initialize database
     """
+    Base.metadata.create_all(engine)
 
-    c = conn.cursor()
+    with Session(engine) as session:
-    c.executescript(
+        if not session.query(SchemaVersion).first():
-        f"""
+            now = datetime.now(timezone.utc)
-        PRAGMA user_version = {SCHEMA};
+            version = SchemaVersion(version=SCHEMA, applied_at=now)
+            session.add(version)
+            session.commit()
 
-        CREATE TABLE IF NOT EXISTS clients (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL UNIQUE,
-            uuid TEXT NOT NULL UNIQUE,
-            endpoint TEXT NOT NULL,
-            last_seen DATETIME NOT NULL
-        );
 
-        CREATE TABLE IF NOT EXISTS torrents (
+def get_schema_version(engine):
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            info_hash_v1 TEXT NOT NULL UNIQUE,
-            info_hash_v2 TEXT UNIQUE,
-            file_count INTEGER NOT NULL,
-            completed_on DATETIME NOT NULL
-        );
-
-        CREATE TABLE IF NOT EXISTS torrent_clients (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            torrent_id INTEGER NOT NULL,
-            client_id INTEGER NOT NULL,
-            name TEXT NOT NULL,
-            content_path TEXT NOT NULL,
-            last_seen DATETIME NOT NULL,
-            FOREIGN KEY (torrent_id) REFERENCES torrents(id),
-            FOREIGN KEY (client_id) REFERENCES clients(id),
-            UNIQUE (torrent_id, client_id)
-        );
-
-        CREATE TABLE IF NOT EXISTS trackers (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            url TEXT NOT NULL UNIQUE,
-            last_seen DATETIME NOT NULL
-        );
-
-        CREATE TABLE IF NOT EXISTS torrent_trackers (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            client_id INTEGER NOT NULL,
-            torrent_id INTEGER NOT NULL,
-            tracker_id INTEGER NOT NULL,
-            last_seen DATETIME NOT NULL,
-            FOREIGN KEY (client_id) REFERENCES clients(id),
-            FOREIGN KEY (torrent_id) REFERENCES torrents(id),
-            FOREIGN KEY (tracker_id) REFERENCES trackers(id),
-            UNIQUE (client_id, torrent_id, tracker_id)
-        );
-
-        CREATE TABLE IF NOT EXISTS files (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            size INTEGER NOT NULL,
-            oshash TEXT NOT NULL UNIQUE,
-            hash TEXT UNIQUE
-        );
-
-        CREATE TABLE IF NOT EXISTS torrent_files (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            file_id INTEGER NOT NULL,
-            torrent_id INTEGER NOT NULL,
-            client_id INTEGER NOT NULL,
-            file_index INTEGER NOT NULL,
-            file_path TEXT NOT NULL,
-            is_downloaded BOOLEAN NOT NULL,
-            last_checked DATETIME NOT NULL,
-            FOREIGN KEY (file_id) REFERENCES files(id),
-            FOREIGN KEY (torrent_id) REFERENCES torrents(id),
-            FOREIGN KEY (client_id) REFERENCES clients(id),
-            UNIQUE (file_id, torrent_id, client_id, file_index)
-        );
     """
-    )
+    Get current schema version from database
-    conn.commit()
+    """
-    c.close()
+    with Session(engine) as session:
+        version = session.query(SchemaVersion).order_by(SchemaVersion.id.desc()).first()
+        return version.version if version else None
 
 
-def list_tables(conn):
+def list_tables(engine):
     """
     List all tables in database
     """
-    c = conn.cursor()
+    inspector = inspect(engine)
-    c.execute("SELECT name FROM sqlite_master WHERE type='table';")
+    return inspector.get_table_names()
-    table_list = c.fetchall()
-    c.close()
-    return [table[0] for table in table_list]
 
 
-def add_client(conn, name, endpoint, last_seen):
+def add_client(engine, name, endpoint, last_seen):
     """
     Add a new client endpoint to database
     """
-    c = conn.cursor()
+    with Session(engine) as session:
-    c.execute(
+        client = Client(
-        f"""
+            uuid=str(uuid.uuid4()), name=name, endpoint=endpoint, last_seen=last_seen
-        INSERT INTO clients (uuid, name, endpoint, last_seen)
-        VALUES ("{uuid.uuid4()}", "{name}", "{endpoint}", "{last_seen}");
-        """
         )
-    conn.commit()
+        session.add(client)
-    c.close()
+        session.commit()
 
 
-def find_client(conn, endpoint):
+def find_client(engine, endpoint):
     """
     Find existing client
     """
-    c = conn.cursor()
+    with Session(engine) as session:
-    c.execute(f'SELECT id, name, uuid FROM clients WHERE endpoint="{endpoint}";')
+        clients = (
-    response = c.fetchall()
+            session.query(Client.id, Client.name, Client.uuid)
-    c.close()
+            .filter_by(endpoint=endpoint)
-    return response
+            .all()
+        )
+        return clients
 
 
-def list_clients(conn):
+def list_clients(engine):
     """
     List all stored clients
     """
-    c = conn.cursor()
+    with Session(engine) as session:
-    c.execute("SELECT * FROM clients;")
+        return session.query(Client).all()
-    rows = c.fetchall()
-    c.close()
-    return rows
 
 
 def main():
@@ -181,50 +117,52 @@ def main():
 
     if args.command == "scan":
         if args.storage is None:
-            STORAGE = os.path.expanduser("~/.tarch.db")
+            storage_path = os.path.expanduser("~/.tarc.db")
         else:
-            STORAGE = args.storage
+            storage_path = args.storage
+
         try:
-            sqlitedb = sqlite3.connect(STORAGE)
+            engine = create_engine(f"sqlite:///{storage_path}")
-            tables = list_tables(sqlitedb)
+            tables = list_tables(engine)
-        except sqlite3.DatabaseError as e:
+        except DatabaseError as e:
-            print(f'[ERROR]: Database Error "{STORAGE}" ({str(e)})')
+            print(f'[ERROR]: Database Error "{storage_path}" ({str(e)})')
             sys.exit(1)
-        if len(tables) == 0:
+
-            print(f"[INFO]: Initializing database at {STORAGE}")
+        if not tables:
-            init_db(sqlitedb)
+            print(f"[INFO]: Initializing database at {storage_path}")
-        cursor = sqlitedb.cursor()
+            init_db(engine)
-        cursor.execute("PRAGMA user_version;")
+
-        SCHEMA_FOUND = cursor.fetchone()[0]
+        schema_found = get_schema_version(engine)
-        cursor.close()
+        if schema_found is None:
-        if not SCHEMA == SCHEMA_FOUND:
+            print("[ERROR]: Could not determine schema version")
-            print(f"[ERROR]: SCHEMA {SCHEMA_FOUND}, expected {SCHEMA}")
             sys.exit(1)
-        if not args.directory is None:
+        if not SCHEMA == schema_found:
+            print(f"[ERROR]: SCHEMA {schema_found}, expected {SCHEMA}")
+            sys.exit(1)
+
+        if args.directory is not None:
             print("[INFO]: --directory is not implemented")
             sys.exit(0)
-        elif not args.endpoint is None:
+        elif args.endpoint is not None:
-            qb = qbittorrent.Client(args.endpoint)
+            qb = qbittorrentapi.Client(host=args.endpoint,
-            if qb.qbittorrent_version is None:
+                                       username=args.username, password=args.password)
-                print(f'[ERROR]: Couldn\'t find client version at "{args.endpoint}"')
+            try:
+                qb.auth_log_in()
+            except qbittorrentapi.LoginFailed as e:
+                print(f'[ERROR]: Login failed for endpoint "{args.endpoint}": {e}')
                 sys.exit(1)
-            elif not re.match(r"^v?\d+(\.\d+)*$", qb.qbittorrent_version):
+            if not re.match(r"^v?\d+(\.\d+)*$", qb.app.version):
-                print(f'[ERROR]: Invalid version found at "{args.endpoint}"')
+                print(f'[ERROR]: Invalid version "{qb.app.version}" found at "{args.endpoint}"')
-                if args.debug:
-                    print(f"[DEBUG]: {qb.qbittorrent_version}")
                 sys.exit(1)
             else:
-                print(
+                print(f'[INFO]: Found qBittorrent {qb.app.version} at "{args.endpoint}"')
-                    f'[INFO]: Found qbittorrent {qb.qbittorrent_version} at "{args.endpoint}"'
+
-                )
+            clients = find_client(engine, args.endpoint)
-            clients = find_client(sqlitedb, args.endpoint)
             if args.confirm_add:
                 if len(clients) == 0:
-                    if not args.name is None:
+                    if args.name is not None:
-                        now = datetime.now(timezone.utc).isoformat(
+                        now = datetime.now(timezone.utc)
-                            sep=" ", timespec="seconds"
+                        add_client(engine, args.name, args.endpoint, now)
-                        )
-                        add_client(sqlitedb, args.name, args.endpoint, now)
                         print(f"[INFO]: Added client {args.name} ({args.endpoint})")
                     else:
                         print("[ERROR]: Must specify --name for a new client")
@@ -242,16 +180,16 @@ def main():
                 print("[ERROR]: Use --confirm-add to add a new endpoint")
                 sys.exit(1)
             elif len(clients) == 1:
-                torrents = qb.torrents()
+                torrents = qb.torrents_info()
                 print(f"[INFO]: There are {len(torrents)} torrents\n")
                 for torrent in torrents[:2]:
-                    files = qb.get_torrent_files(torrent["hash"])
+                    files = qb.torrents_files(torrent.hash)
-                    trackers = qb.get_torrent_trackers(torrent["hash"])
+                    trackers = qb.torrents_trackers(torrent.hash)
-                    print(f"[name]: {torrent['name']}")
+                    print(f"[name]: {torrent.name}")
-                    print(f"[infohash_v1]: {torrent['infohash_v1']}")
+                    print(f"[infohash_v1]: {torrent.hash}")
-                    print(f"[content_path]: {torrent['content_path']}")
+                    print(f"[content_path]: {torrent.content_path}")
-                    print(f"[magent_uri]: {torrent['magnet_uri'][0:80]}")
+                    print(f"[magnet_uri]: {torrent.magnet_uri[:80]}")
-                    print(f"[completed_on]: {torrent['completed']}")
+                    print(f"[completed_on]: {torrent.completed}\n")
                     print(f"[trackers]: {len(trackers)}")
                     print(f"[file_count]: {len(files)}\n")
                     if args.debug:

tarc/models.py

@@ -0,0 +1,106 @@
+"""SQLAlchemy models for the tarc database."""
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    Boolean,
+    ForeignKey,
+    UniqueConstraint,
+)
+from sqlalchemy.orm import declarative_base
+
+Base = declarative_base()
+
+
+class SchemaVersion(Base):  # pylint: disable=too-few-public-methods
+    """Database schema version tracking."""
+
+    __tablename__ = "schema_version"
+    id = Column(Integer, primary_key=True)
+    version = Column(Integer, nullable=False)
+    applied_at = Column(DateTime, nullable=False)
+
+
+class Client(Base):  # pylint: disable=too-few-public-methods
+    """BitTorrent client instance."""
+
+    __tablename__ = "clients"
+    id = Column(Integer, primary_key=True)
+    name = Column(String, nullable=False, unique=True)
+    uuid = Column(String, nullable=False, unique=True)
+    endpoint = Column(String, nullable=False)
+    last_seen = Column(DateTime, nullable=False)
+
+
+class Torrent(Base):  # pylint: disable=too-few-public-methods
+    """BitTorrent metadata."""
+
+    __tablename__ = "torrents"
+    id = Column(Integer, primary_key=True)
+    info_hash_v1 = Column(String, nullable=False, unique=True)
+    info_hash_v2 = Column(String, unique=True)
+    file_count = Column(Integer, nullable=False)
+    completed_on = Column(DateTime, nullable=False)
+
+
+class TorrentClient(Base):  # pylint: disable=too-few-public-methods
+    """Association between torrents and clients."""
+
+    __tablename__ = "torrent_clients"
+    id = Column(Integer, primary_key=True)
+    torrent_id = Column(Integer, ForeignKey("torrents.id"), nullable=False)
+    client_id = Column(Integer, ForeignKey("clients.id"), nullable=False)
+    name = Column(String, nullable=False)
+    content_path = Column(String, nullable=False)
+    last_seen = Column(DateTime, nullable=False)
+    __table_args__ = (UniqueConstraint("torrent_id", "client_id"),)
+
+
+class Tracker(Base):  # pylint: disable=too-few-public-methods
+    """BitTorrent tracker information."""
+
+    __tablename__ = "trackers"
+    id = Column(Integer, primary_key=True)
+    url = Column(String, nullable=False, unique=True)
+    last_seen = Column(DateTime, nullable=False)
+
+
+class TorrentTracker(Base):  # pylint: disable=too-few-public-methods
+    """Association between torrents and trackers."""
+
+    __tablename__ = "torrent_trackers"
+    id = Column(Integer, primary_key=True)
+    client_id = Column(Integer, ForeignKey("clients.id"), nullable=False)
+    torrent_id = Column(Integer, ForeignKey("torrents.id"), nullable=False)
+    tracker_id = Column(Integer, ForeignKey("trackers.id"), nullable=False)
+    last_seen = Column(DateTime, nullable=False)
+    __table_args__ = (UniqueConstraint("client_id", "torrent_id", "tracker_id"),)
+
+
+class File(Base):  # pylint: disable=too-few-public-methods
+    """File metadata and hashes."""
+
+    __tablename__ = "files"
+    id = Column(Integer, primary_key=True)
+    size = Column(Integer, nullable=False)
+    oshash = Column(String, nullable=False, unique=True)
+    hash = Column(String, unique=True)
+
+
+class TorrentFile(Base):  # pylint: disable=too-few-public-methods
+    """Association between torrents and files."""
+
+    __tablename__ = "torrent_files"
+    id = Column(Integer, primary_key=True)
+    file_id = Column(Integer, ForeignKey("files.id"), nullable=False)
+    torrent_id = Column(Integer, ForeignKey("torrents.id"), nullable=False)
+    client_id = Column(Integer, ForeignKey("clients.id"), nullable=False)
+    file_index = Column(Integer, nullable=False)
+    file_path = Column(String, nullable=False)
+    is_downloaded = Column(Boolean, nullable=False)
+    last_checked = Column(DateTime, nullable=False)
+    __table_args__ = (
+        UniqueConstraint("file_id", "torrent_id", "client_id", "file_index"),
+    )