torrents-info: add qbt_torrents.py functionality

Author: chapmanjacobd

library/playback/torrents_info.py

@@ -3,13 +3,48 @@
 
 from library import usage
 from library.mediafiles import torrents_start
+from library.utils import arggroups, argparse_utils, consts, iterables, printing, strings
+from library.mediafiles import torrents_start
 from library.utils import arggroups, argparse_utils, consts, iterables, printing, processes, strings
 from library.utils.path_utils import domain_from_url
 
 
 def parse_args():
     parser = argparse_utils.ArgumentParser(usage=usage.torrents_info)
     arggroups.qBittorrent(parser)
+    parser.add_argument(
+        "--downloading",
+        "--download",
+        "--down",
+        "--dl",
+        "--leech",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Include downloading torrents",
+    )
+    parser.add_argument(
+        "--uploading",
+        "--upload",
+        "--up",
+        "--ul",
+        "--seeds",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="Include uploading torrents",
+    )
+
+    parser.add_argument("--priority", action='store_true', help="Sort by priority")
+
+    parser.add_argument("--active", action=argparse.BooleanOptionalAction, default=True, help="Show active torrents")
+    parser.add_argument(
+        "--inactive", "--dead", action=argparse.BooleanOptionalAction, default=False, help="Show inactive torrents"
+    )
+
+    parser.add_argument("--status", action=argparse.BooleanOptionalAction, default=True, help="Show status summary")
+    parser.add_argument("--transfers", action=argparse.BooleanOptionalAction, default=True, help="Show transfer summary")
+    parser.add_argument("--trackers", action=argparse.BooleanOptionalAction, default=False, help="Show tracker summary")
+    parser.add_argument("--file-count", "--count", action='store_true', help="Include file counts (a bit slow)")
+
     parser.add_argument(
         "--force-start", "--start", action=argparse.BooleanOptionalAction, help="Force start matching torrents"
     )
@@ -36,49 +71,118 @@ def qbt_get_tracker(qbt_client, torrent):
 def torrents_info():
     args = parse_args()
 
+    def shorten(s, width):
+        return s if args.verbose >= consts.LOG_INFO else strings.shorten(s, width)
+
     qbt_client = torrents_start.start_qBittorrent(args)
-    all_torrents = qbt_client.torrents_info()
+    torrents = qbt_client.torrents_info()
+
+    torrents = [
+        t
+        for t in torrents
+        if t.state_enum.is_downloading == args.downloading or t.state_enum.is_uploading == args.uploading
+    ]
 
     if args.torrent_search or args.file_search:
-        torrents = [t for t in all_torrents if strings.glob_match(args.torrent_search, [t.name, t.save_path, t.hash])]
+        torrents = [t for t in torrents if strings.glob_match(args.torrent_search, [t.name, t.save_path, t.hash])]
 
         if args.file_search:
             torrents = [t for t in torrents if strings.glob_match(args.file_search, [f.name for f in t.files])]
 
-        if not torrents:
-            processes.no_media_found()
+    if not torrents:
+        processes.no_media_found()
 
-        torrents = sorted(torrents, key=lambda t: -t.time_active)
-        for torrent in torrents:
-            printing.extended_view(torrent)
+    if args.downloading and not args.uploading:
+        if args.priority:
+            torrents = sorted(torrents, key=lambda t: t.priority)
+        else:
+            torrents = sorted(torrents, key=lambda t: t.eta)
+    else:
+        torrents = sorted(torrents, key=lambda t: (t.added_on, t.time_active))
 
-            files = torrent.files
-            if args.file_search:
-                files = [f for f in torrent.files if strings.glob_match(args.file_search, [f.name])]
+    if args.torrent_search or args.file_search:
+        print(len(torrents), "matching torrents")
+
+    if args.inactive:
+        active_torrents = [t for t in torrents if t.downloaded_session > 0]
+        if active_torrents:
+            print('Active')
+
+            def gen_row(t):
+                d = {
+                    'name': shorten(t.name, 35),
+                    "num_seeds": f"{t.num_seeds} ({t.num_complete})",
+                    'progress': strings.safe_percent(t.progress),
+                    'remaining': strings.file_size(t.amount_left),
+                    'speed': strings.file_size(t.dlspeed) + '/s' if t.dlspeed else None,
+                    'eta': strings.duration(t.eta),
+                    'downloaded_session': strings.file_size(t.downloaded_session),
+                }
+                if args.file_search:
+                    files = t.files
+                    files = [f for f in t.files if strings.glob_match(args.file_search, [f.name])]
+
+                    print(t.name)
+                    printing.extended_view(files)
+                    print()
+
+                    d |= {'files': f"{len(files)} ({len(t.files)})"}
+                if args.verbose >= consts.LOG_INFO:
+                    d |= {
+                        'tracker': qbt_get_tracker(qbt_client, t),
+                        'seen_complete': strings.relative_datetime(t.seen_complete),
+                        'added_on': strings.relative_datetime(t.added_on),
+                        'last_activity': strings.relative_datetime(t.last_activity),
+                        'size': strings.file_size(t.total_size),
+                        'comment': t.comment,
+                        'content_path': t.content_path,
+                    }
 
-            if args.verbose >= consts.LOG_INFO:
-                printing.extended_view(files)
+                return d
 
-            if len(torrent.files) == 1:
-                print("1 file")
-            elif args.file_search:
-                print(len(files), "files of", len(torrent.files), "matched")
-            else:
-                print(len(torrent.files), "total files")
-            print()
+            printing.table(iterables.conform([gen_row(t) for t in active_torrents]))
+
+    if args.inactive:
+        inactive_torrents = [t for t in torrents if t.downloaded_session == 0]
+        if inactive_torrents:
+            print('Inactive')
+            inactive_torrents = sorted(
+                inactive_torrents, key=lambda t: (t.downloaded > 0, t.time_active * t.last_activity)
+            )
 
-        print(len(torrents), "matched torrents")
+            def gen_row(t):
+                d = {
+                    'name': shorten(t.name, 50),
+                    'progress': strings.safe_percent(t.progress),
+                    'downloaded': strings.file_size(t.downloaded),
+                    'time_active': strings.duration(t.time_active),
+                    "num_seeds": f"{t.num_seeds} ({t.num_complete})",
+                    'seen_complete': strings.relative_datetime(t.seen_complete),
+                    'last_activity': strings.relative_datetime(t.last_activity),
+                }
+                if args.file_search:
+                    files = t.files
+                    files = [f for f in t.files if strings.glob_match(args.file_search, [f.name])]
+
+                    print(t.name)
+                    printing.extended_view(files)
+                    print()
+
+                    d |= {'files': f"{len(files)} ({len(t.files)})"}
+                if args.verbose >= consts.LOG_INFO:
+                    d |= {
+                        'state': t.state,
+                        'tracker': qbt_get_tracker(qbt_client, t),
+                        'added_on': strings.relative_datetime(t.added_on),
+                        'size': strings.file_size(t.total_size),
+                        'remaining': strings.file_size(t.amount_left),
+                        'comment': t.comment,
+                        'content_path': t.content_path,
+                    }
 
-        torrent_hashes = [t.hash for t in torrents]
-        if args.mark_deleted:
-            qbt_client.torrents_add_tags(tags="library-delete", torrent_hashes=torrent_hashes)
-        elif args.delete_files:
-            qbt_client.torrents_delete(delete_files=True, torrent_hashes=torrent_hashes)
-        elif args.delete_rows:
-            qbt_client.torrents_delete(delete_files=False, torrent_hashes=torrent_hashes)
-        elif args.force_start is not None:
-            qbt_client.torrents_set_force_start(args.force_start, torrent_hashes=torrent_hashes)
-        return
+                return d
+
+            printing.table(iterables.conform([gen_row(t) for t in torrents]))
 
     interesting_states = [
         "stoppedUP",
@@ -94,36 +198,34 @@ def torrents_info():
         "error",
     ]
 
-    torrents_by_state = {}
-    for torrent in all_torrents:
-        torrents_by_state.setdefault(torrent.state, []).append(torrent)
-
-    if args.verbose >= consts.LOG_INFO:
-        torrents_by_tracker = {}
-        for torrent in all_torrents:
-            torrents_by_tracker.setdefault(qbt_get_tracker(qbt_client, torrent), []).append(torrent)
+    if args.status:
+        torrents_by_state = {}
+        for torrent in torrents:
+            torrents_by_state.setdefault(torrent.state, []).append(torrent)
 
         tbl = []
         for state in {*interesting_states} - {"uploading", "downloading"}:
-            torrents = torrents_by_state.get(state)
-            if not torrents:
+            state_torrents = torrents_by_state.get(state)
+            if not state_torrents:
                 continue
 
-            torrents = sorted(torrents, key=lambda t: (-t.seen_complete, t.time_active))
+            state_torrents = sorted(state_torrents, key=lambda t: (-t.seen_complete, t.time_active))
 
             tbl.extend(
                 [
                     {
                         "state": state,
                         "name": printing.path_fill(t.name, width=76),
-                        "seen_complete": strings.relative_datetime(t.seen_complete) if t.seen_complete > 0 else None,
+                        "seen_complete": (
+                            strings.relative_datetime(t.seen_complete) if t.seen_complete > 0 else None
+                        ),
                         "last_activity": strings.relative_datetime(t.last_activity),
                         "time_active": strings.duration(t.time_active),
                         "num_seeds": f"{t.num_seeds} ({t.num_complete})",
                         # 'num_leechs': f"{t.num_leechs} ({t.num_incomplete})",
                         # 'comment': t.comment,
                     }
-                    for t in torrents
+                    for t in state_torrents
                 ]
             )
         if tbl:
@@ -132,12 +234,12 @@ def torrents_info():
 
         tbl = []
         for state in ["downloading", "missingFiles", "error"]:
-            torrents = torrents_by_state.get(state)
-            if not torrents:
+            state_torrents = torrents_by_state.get(state)
+            if not state_torrents:
                 continue
 
-            torrents = sorted(
-                torrents, key=lambda t: (t.amount_left == t.total_size, t.eta, t.amount_left), reverse=True
+            state_torrents = sorted(
+                state_torrents, key=lambda t: (t.amount_left == t.total_size, t.eta, t.amount_left), reverse=True
             )
 
             tbl.extend(
@@ -149,25 +251,59 @@ def torrents_info():
                         "eta": strings.duration(t.eta) if t.eta < 8640000 else None,
                         "remaining": strings.file_size(t.amount_left),
                     }
-                    for t in torrents
+                    for t in state_torrents
                 ]
             )
         if tbl:
             printing.table(tbl)
             print()
 
+        categories = []
+        for state, state_torrents in torrents_by_state.items():
+            remaining = sum(t.amount_left for t in state_torrents)
+            categories.append(
+                {
+                    "state": state,
+                    "count": len(state_torrents),
+                    "size": strings.file_size(sum(t.total_size for t in state_torrents)),
+                    "remaining": strings.file_size(remaining) if remaining else None,
+                    "file_count": (
+                        sum(len(t.files) for t in state_torrents) if args.verbose >= 2 else None
+                    ),  # a bit slow
+                }
+            )
+
+        categories = sorted(
+            categories,
+            key=lambda d: (
+                d["state"].endswith(("missingFiles", "error")),
+                d["state"].endswith(("downloading", "DL")),
+                iterables.safe_index(interesting_states, d["state"]),
+            ),
+        )
+        printing.table(iterables.list_dict_filter_bool(categories))
+        print()
+
+    if args.trackers:
+        torrents_by_tracker = {}
+        for torrent in torrents:
+            torrents_by_tracker.setdefault(qbt_get_tracker(qbt_client, torrent), []).append(torrent)
+
+
         trackers = []
-        for tracker, torrents in torrents_by_tracker.items():
-            torrents = [t for t in torrents if args.verbose >= 2 or t.state not in ("stoppedDL",)]
-            remaining = sum(t.amount_left for t in torrents)
+        for tracker, tracker_torrents in torrents_by_tracker.items():
+            tracker_torrents = [t for t in tracker_torrents if args.verbose >= 2 or t.state not in ("stoppedDL",)]
+            remaining = sum(t.amount_left for t in tracker_torrents)
             if remaining or args.verbose >= 2:
                 trackers.append(
                     {
                         "tracker": tracker,
-                        "count": len(torrents),
-                        "size": sum(t.total_size for t in torrents),
+                        "count": len(tracker_torrents),
+                        "size": sum(t.total_size for t in tracker_torrents),
                         "remaining": remaining,
-                        "file_count": sum(len(t.files) for t in torrents) if args.verbose >= 2 else None,  # a bit slow
+                        "file_count": (
+                            sum(len(t.files) for t in tracker_torrents) if args.verbose >= 2 else None
+                        ),  # a bit slow
                     }
                 )
         if trackers:
@@ -183,39 +319,26 @@ def torrents_info():
             printing.table(iterables.list_dict_filter_bool(trackers))
             print()
 
-    categories = []
-    for state, torrents in torrents_by_state.items():
-        remaining = sum(t.amount_left for t in torrents)
-        categories.append(
-            {
-                "state": state,
-                "count": len(torrents),
-                "size": strings.file_size(sum(t.total_size for t in torrents)),
-                "remaining": strings.file_size(remaining) if remaining else None,
-                "file_count": sum(len(t.files) for t in torrents) if args.verbose >= 2 else None,  # a bit slow
-            }
-        )
-
-    categories = sorted(
-        categories,
-        key=lambda d: (
-            d["state"].endswith(("missingFiles", "error")),
-            d["state"].endswith(("downloading", "DL")),
-            iterables.safe_index(interesting_states, d["state"]),
-        ),
-    )
-    printing.table(iterables.list_dict_filter_bool(categories))
-    print()
-
-    transfer = qbt_client.transfer_info()
-    print(transfer.connection_status.upper())
-
-    dl_speed = strings.file_size(transfer.dl_info_speed)
-    dl_limit = f"[{strings.file_size(transfer.dl_rate_limit)}/s]" if transfer.dl_rate_limit > 0 else ""
-    dl_d = strings.file_size(transfer.dl_info_data)
-    print(f"DL {dl_speed}/s {dl_limit} ({dl_d})")
-
-    up_speed = strings.file_size(transfer.up_info_speed)
-    up_limit = f"[{strings.file_size(transfer.up_rate_limit)}/s]" if transfer.up_rate_limit > 0 else ""
-    up_d = strings.file_size(transfer.up_info_data)
-    print(f"UP {up_speed}/s {up_limit} ({up_d})")
+    if args.transfers:
+        transfer = qbt_client.transfer_info()
+        print(transfer.connection_status.upper())
+
+        dl_speed = strings.file_size(transfer.dl_info_speed)
+        dl_limit = f"[{strings.file_size(transfer.dl_rate_limit)}/s]" if transfer.dl_rate_limit > 0 else ""
+        dl_d = strings.file_size(transfer.dl_info_data)
+        print(f"DL {dl_speed}/s {dl_limit} ({dl_d})")
+
+        up_speed = strings.file_size(transfer.up_info_speed)
+        up_limit = f"[{strings.file_size(transfer.up_rate_limit)}/s]" if transfer.up_rate_limit > 0 else ""
+        up_d = strings.file_size(transfer.up_info_data)
+        print(f"UP {up_speed}/s {up_limit} ({up_d})")
+
+    torrent_hashes = [t.hash for t in torrents]
+    if args.mark_deleted:
+        qbt_client.torrents_add_tags(tags="library-delete", torrent_hashes=torrent_hashes)
+    elif args.delete_files:
+        qbt_client.torrents_delete(delete_files=True, torrent_hashes=torrent_hashes)
+    elif args.delete_rows:
+        qbt_client.torrents_delete(delete_files=False, torrent_hashes=torrent_hashes)
+    elif args.force_start is not None:
+        qbt_client.torrents_set_force_start(args.force_start, torrent_hashes=torrent_hashes)