rclone-api 1.0.72__tar.gz → 1.0.75__tar.gz

{rclone_api-1.0.72 → rclone_api-1.0.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.0.72
+Version: 1.0.75
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 Maintainer: Zachary Vorhies

{rclone_api-1.0.72 → rclone_api-1.0.75}/pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
     "python-dotenv>=1.0.0",
 ]
 # Change this with the version number bump.
-version = "1.0.72"
+version = "1.0.75"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

{rclone_api-1.0.72 → rclone_api-1.0.75}/src/rclone_api/diff.py

@@ -126,19 +126,18 @@ def _async_diff_stream_from_running_process(
             except UnicodeDecodeError:
                 print("UnicodeDecodeError")
                 continue
-        output.put(None)
     except KeyboardInterrupt:
         import _thread
 
         print("KeyboardInterrupt")
-        output.put(None)
         _thread.interrupt_main()
     except Exception as e:
         import _thread
 
         print(f"Error: {e}")
-        output.put(None)
         _thread.interrupt_main()
+    finally:
+        output.put(None)
 
 
 def diff_stream_from_running_process(

{rclone_api-1.0.72 → rclone_api-1.0.75}/src/rclone_api/dir.py

@@ -66,7 +66,7 @@ class Dir:
         self_path = Path(self.path.path)
         other_path = Path(other.path.path)
         rel_path = self_path.relative_to(other_path)
-        return str(rel_path)
+        return str(rel_path.as_posix())
 
     def walk(
         self, breadth_first: bool, max_depth: int = -1

{rclone_api-1.0.72 → rclone_api-1.0.75}/src/rclone_api/rclone.py

@@ -349,11 +349,15 @@ class Rclone:
         dst: str,
         files: list[str] | Path,
         check: bool | None = None,
+        max_backlog: int | None = None,
         verbose: bool | None = None,
         checkers: int | None = None,
         transfers: int | None = None,
         low_level_retries: int | None = None,
         retries: int | None = None,
+        retries_sleep: str | None = None,
+        metadata: bool | None = None,
+        timeout: str | None = None,
         max_partition_workers: int | None = None,
         other_args: list[str] | None = None,
     ) -> list[CompletedProcess]:
@@ -444,6 +448,14 @@ class Rclone:
                             "--retries",
                             str(retries),
                         ]
+                        if metadata:
+                            cmd_list.append("--metadata")
+                        if retries_sleep is not None:
+                            cmd_list += ["--retries-sleep", retries_sleep]
+                        if timeout is not None:
+                            cmd_list += ["--timeout", timeout]
+                        if max_backlog is not None:
+                            cmd_list += ["--max-backlog", str(max_backlog)]
                         if verbose:
                             if not any(["-v" in x for x in other_args]):
                                 cmd_list.append("-vvvv")

{rclone_api-1.0.72 → rclone_api-1.0.75}/src/rclone_api/scan_missing_folders.py

@@ -13,41 +13,59 @@ from rclone_api.walk import walk_runner_depth_first
 _MAX_OUT_QUEUE_SIZE = 50
 
 
+def _reorder_inplace(data: list, order: Order) -> None:
+    if order == Order.NORMAL:
+        return
+    elif order == Order.REVERSE:
+        data.reverse()
+        return
+    elif order == Order.RANDOM:
+        random.shuffle(data)
+        return
+    else:
+        raise ValueError(f"Invalid order: {order}")
+
+
 # ONLY Works from src -> dst diffing.
 def _async_diff_dir_walk_task(
     src: Dir, dst: Dir, max_depth: int, out_queue: Queue[Dir | None], order: Order
 ) -> None:
-    curr_src, curr_dst = src, dst
+    can_scan_two_deep = max_depth > 1 or max_depth == -1
+    ls_depth = 2 if can_scan_two_deep else 1
     with ThreadPoolExecutor(max_workers=2) as executor:
         t1 = executor.submit(
-            src.ls, listing_option=ListingOption.DIRS_ONLY, order=order
+            src.ls,
+            listing_option=ListingOption.DIRS_ONLY,
+            order=order,
+            max_depth=ls_depth,
         )
         t2 = executor.submit(
-            dst.ls, listing_option=ListingOption.DIRS_ONLY, order=order
+            dst.ls,
+            listing_option=ListingOption.DIRS_ONLY,
+            order=order,
+            max_depth=ls_depth,
         )
         src_dir_listing: DirListing = t1.result()
         dst_dir_listing: DirListing = t2.result()
-    next_depth = max_depth - 1 if max_depth > 0 else max_depth
-    dst_dirs: list[str] = [d.name for d in dst_dir_listing.dirs]
-    src_dirs: list[str] = [d.name for d in src_dir_listing.dirs]
+    next_depth = max_depth - ls_depth if max_depth > 0 else max_depth
+    dst_dirs: list[str] = [d.relative_to(src) for d in dst_dir_listing.dirs]
+    src_dirs: list[str] = [d.relative_to(dst) for d in src_dir_listing.dirs]
     dst_files_set: set[str] = set(dst_dirs)
     matching_dirs: list[str] = []
-    if order == Order.REVERSE:
-        src_dirs.reverse()
-        dst_dirs.reverse()
-    elif order == Order.RANDOM:
-        random.shuffle(src_dirs)
-        random.shuffle(dst_dirs)
-    for file in src_dirs:
-        if file not in dst_files_set:
+    _reorder_inplace(src_dirs, order)
+    _reorder_inplace(dst_dirs, order)
+    for i, src_dir in enumerate(src_dirs):
+        src_dir_dir = src / src_dir
+        if src_dir not in dst_files_set:
             queue_dir_listing: Queue[DirListing | None] = Queue()
             if next_depth > 0 or next_depth == -1:
                 walk_runner_depth_first(
-                    dir=curr_src,
+                    dir=src_dir_dir,
                     out_queue=queue_dir_listing,
                     order=order,
                     max_depth=next_depth,
                 )
+                out_queue.put(src)
             while dirlisting := queue_dir_listing.get():
                 if dirlisting is None:
                     break
@@ -55,13 +73,13 @@ def _async_diff_dir_walk_task(
                 for d in dirlisting.dirs:
                     out_queue.put(d)
         else:
-            matching_dirs.append(file)
+            matching_dirs.append(src_dir)
 
     for matching_dir in matching_dirs:
         # print(f"matching dir: {matching_dir}")
         if next_depth > 0 or next_depth == -1:
-            src_next = curr_src / matching_dir
-            dst_next = curr_dst / matching_dir
+            src_next = src / matching_dir
+            dst_next = dst / matching_dir
             _async_diff_dir_walk_task(
                 src=src_next,
                 dst=dst_next,

{rclone_api-1.0.72 → rclone_api-1.0.75}/src/rclone_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.0.72
+Version: 1.0.75
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 Maintainer: Zachary Vorhies

{rclone_api-1.0.72 → rclone_api-1.0.75}/tests/test_diff.py

@@ -83,7 +83,7 @@ class RcloneDiffTests(unittest.TestCase):
                 item.type, DiffType.MISSING_ON_DST
             )  # should be equal because same repo
             all.append(item)
-        self.assertGreater(len(all), 0)
+        self.assertEqual(len(all), 47)
         msg = "\n".join([str(item) for item in all])
         print(msg)
 
@@ -98,7 +98,7 @@ class RcloneDiffTests(unittest.TestCase):
         ):
             self.assertEqual(item.type, DiffType.MISSING_ON_SRC)
             all.append(item)
-        self.assertGreater(len(all), 0)
+        self.assertEqual(len(all), 47)
         msg = "\n".join([str(item) for item in all])
         print(msg)