rclone-api 1.5.41__py3-none-any.whl → 1.5.43__py3-none-any.whl

rclone_api/config.py

@@ -47,11 +47,22 @@ class Parsed:
         return parse_rclone_config(content)
 
 
-@dataclass
 class Config:
     """Rclone configuration dataclass."""
 
-    text: str
+    # text: str
+    def __init__(self, text: str | dict) -> None:
+        self.text: str
+        if isinstance(text, dict):
+            self.text = _json_to_rclone_config_str_or_raise(text)
+        else:
+            self.text = text
+
+        try:
+            new_text = _json_to_rclone_config_str_or_raise(self.text)
+            self.text = new_text
+        except Exception:
+            pass
 
     @staticmethod
     def from_json(json_data: dict) -> "Config | Exception":
@@ -60,16 +71,6 @@ class Config:
     def parse(self) -> Parsed:
         return Parsed.parse(self.text)
 
-    def _auto_convert_if_json(self) -> None:
-        try:
-            text = _json_to_rclone_config_str_or_raise(self.text)
-            self.text = text
-        except Exception:
-            pass
-
-    def __post_init__(self) -> None:
-        self._auto_convert_if_json()
-
 
 def find_conf_file(rclone: Any | None = None) -> Path | None:
     import subprocess

rclone_api/db/__init__.py

@@ -1,3 +1,3 @@
-from .db import DB
-
-__all__ = ["DB"]
+from .db import DB
+
+__all__ = ["DB"]

rclone_api/detail/walk.py

@@ -1,116 +1,116 @@
-import random
-from queue import Queue
-from threading import Thread
-from typing import Generator
-
-from rclone_api import Dir
-from rclone_api.dir_listing import DirListing
-from rclone_api.remote import Remote
-from rclone_api.types import Order
-
-_MAX_OUT_QUEUE_SIZE = 50
-
-
-def walk_runner_breadth_first(
-    dir: Dir,
-    max_depth: int,
-    out_queue: Queue[DirListing | None],
-    order: Order = Order.NORMAL,
-) -> None:
-    queue: Queue[Dir] = Queue()
-    queue.put(dir)
-    try:
-        while not queue.empty():
-            current_dir = queue.get()
-            dirlisting = current_dir.ls(max_depth=0, order=order)
-            out_queue.put(dirlisting)
-            dirs = dirlisting.dirs
-
-            if max_depth != 0 and len(dirs) > 0:
-                for child in dirs:
-                    queue.put(child)
-            if max_depth < 0:
-                continue
-            if max_depth > 0:
-                max_depth -= 1
-        out_queue.put(None)
-    except KeyboardInterrupt:
-        import _thread
-
-        out_queue.put(None)
-
-        _thread.interrupt_main()
-
-
-def walk_runner_depth_first(
-    dir: Dir,
-    max_depth: int,
-    out_queue: Queue[DirListing | None],
-    order: Order = Order.NORMAL,
-) -> None:
-    try:
-        stack = [(dir, max_depth)]
-        while stack:
-            current_dir, depth = stack.pop()
-            dirlisting = current_dir.ls()
-            if order == Order.REVERSE:
-                dirlisting.dirs.reverse()
-            if order == Order.RANDOM:
-
-                random.shuffle(dirlisting.dirs)
-            if depth != 0:
-                for subdir in dirlisting.dirs:  # Process deeper directories first
-                    # stack.append((child, depth - 1 if depth > 0 else depth))
-                    next_depth = depth - 1 if depth > 0 else depth
-                    walk_runner_depth_first(subdir, next_depth, out_queue, order=order)
-            out_queue.put(dirlisting)
-        out_queue.put(None)
-    except KeyboardInterrupt:
-        import _thread
-
-        out_queue.put(None)
-        _thread.interrupt_main()
-
-
-def walk(
-    dir: Dir | Remote,
-    breadth_first: bool,
-    max_depth: int = -1,
-    order: Order = Order.NORMAL,
-) -> Generator[DirListing, None, None]:
-    """Walk through the given directory recursively.
-
-    Args:
-        dir: Directory or Remote to walk through
-        max_depth: Maximum depth to traverse (-1 for unlimited)
-
-    Yields:
-        DirListing: Directory listing for each directory encountered
-    """
-    try:
-        # Convert Remote to Dir if needed
-        if isinstance(dir, Remote):
-            dir = Dir(dir)
-        out_queue: Queue[DirListing | None] = Queue(maxsize=_MAX_OUT_QUEUE_SIZE)
-
-        def _task() -> None:
-            if breadth_first:
-                walk_runner_breadth_first(dir, max_depth, out_queue, order)
-            else:
-                walk_runner_depth_first(dir, max_depth, out_queue, order)
-
-        # Start worker thread
-        worker = Thread(
-            target=_task,
-            daemon=True,
-        )
-        worker.start()
-
-        while dirlisting := out_queue.get():
-            if dirlisting is None:
-                break
-            yield dirlisting
-
-        worker.join()
-    except KeyboardInterrupt:
-        pass
+import random
+from queue import Queue
+from threading import Thread
+from typing import Generator
+
+from rclone_api import Dir
+from rclone_api.dir_listing import DirListing
+from rclone_api.remote import Remote
+from rclone_api.types import Order
+
+_MAX_OUT_QUEUE_SIZE = 50
+
+
+def walk_runner_breadth_first(
+    dir: Dir,
+    max_depth: int,
+    out_queue: Queue[DirListing | None],
+    order: Order = Order.NORMAL,
+) -> None:
+    queue: Queue[Dir] = Queue()
+    queue.put(dir)
+    try:
+        while not queue.empty():
+            current_dir = queue.get()
+            dirlisting = current_dir.ls(max_depth=0, order=order)
+            out_queue.put(dirlisting)
+            dirs = dirlisting.dirs
+
+            if max_depth != 0 and len(dirs) > 0:
+                for child in dirs:
+                    queue.put(child)
+            if max_depth < 0:
+                continue
+            if max_depth > 0:
+                max_depth -= 1
+        out_queue.put(None)
+    except KeyboardInterrupt:
+        import _thread
+
+        out_queue.put(None)
+
+        _thread.interrupt_main()
+
+
+def walk_runner_depth_first(
+    dir: Dir,
+    max_depth: int,
+    out_queue: Queue[DirListing | None],
+    order: Order = Order.NORMAL,
+) -> None:
+    try:
+        stack = [(dir, max_depth)]
+        while stack:
+            current_dir, depth = stack.pop()
+            dirlisting = current_dir.ls()
+            if order == Order.REVERSE:
+                dirlisting.dirs.reverse()
+            if order == Order.RANDOM:
+
+                random.shuffle(dirlisting.dirs)
+            if depth != 0:
+                for subdir in dirlisting.dirs:  # Process deeper directories first
+                    # stack.append((child, depth - 1 if depth > 0 else depth))
+                    next_depth = depth - 1 if depth > 0 else depth
+                    walk_runner_depth_first(subdir, next_depth, out_queue, order=order)
+            out_queue.put(dirlisting)
+        out_queue.put(None)
+    except KeyboardInterrupt:
+        import _thread
+
+        out_queue.put(None)
+        _thread.interrupt_main()
+
+
+def walk(
+    dir: Dir | Remote,
+    breadth_first: bool,
+    max_depth: int = -1,
+    order: Order = Order.NORMAL,
+) -> Generator[DirListing, None, None]:
+    """Walk through the given directory recursively.
+
+    Args:
+        dir: Directory or Remote to walk through
+        max_depth: Maximum depth to traverse (-1 for unlimited)
+
+    Yields:
+        DirListing: Directory listing for each directory encountered
+    """
+    try:
+        # Convert Remote to Dir if needed
+        if isinstance(dir, Remote):
+            dir = Dir(dir)
+        out_queue: Queue[DirListing | None] = Queue(maxsize=_MAX_OUT_QUEUE_SIZE)
+
+        def _task() -> None:
+            if breadth_first:
+                walk_runner_breadth_first(dir, max_depth, out_queue, order)
+            else:
+                walk_runner_depth_first(dir, max_depth, out_queue, order)
+
+        # Start worker thread
+        worker = Thread(
+            target=_task,
+            daemon=True,
+        )
+        worker.start()
+
+        while dirlisting := out_queue.get():
+            if dirlisting is None:
+                break
+            yield dirlisting
+
+        worker.join()
+    except KeyboardInterrupt:
+        pass

rclone_api/dir.py

@@ -1,113 +1,113 @@
-import json
-from pathlib import Path
-from typing import Generator
-
-from rclone_api.dir_listing import DirListing
-from rclone_api.remote import Remote
-from rclone_api.rpath import RPath
-from rclone_api.types import ListingOption, Order
-
-
-class Dir:
-    """Remote file dataclass."""
-
-    @property
-    def remote(self) -> Remote:
-        return self.path.remote
-
-    @property
-    def name(self) -> str:
-        return self.path.name
-
-    def __init__(self, path: RPath | Remote) -> None:
-        """Initialize Dir with either an RPath or Remote.
-
-        Args:
-            path: Either an RPath object or a Remote object
-        """
-        if isinstance(path, Remote):
-            # Need to create an RPath for the Remote's root
-            self.path = RPath(
-                remote=path,
-                path=str(path),
-                name=str(path),
-                size=0,
-                mime_type="inode/directory",
-                mod_time="",
-                is_dir=True,
-            )
-            # Ensure the RPath has the same rclone instance as the Remote
-            self.path.set_rclone(path.rclone)
-        else:
-            self.path = path
-        # self.path.set_rclone(self.path.remote.rclone)
-        assert self.path.rclone is not None
-
-    def ls(
-        self,
-        max_depth: int | None = None,
-        glob: str | None = None,
-        order: Order = Order.NORMAL,
-        listing_option: ListingOption = ListingOption.ALL,
-    ) -> DirListing:
-        """List files and directories in the given path."""
-        assert self.path.rclone is not None
-        dir = Dir(self.path)
-        return self.path.rclone.ls(
-            dir,
-            max_depth=max_depth,
-            glob=glob,
-            order=order,
-            listing_option=listing_option,
-        )
-
-    def relative_to(self, other: "Dir") -> str:
-        """Return the relative path to the other directory."""
-        self_path = Path(self.path.path)
-        other_path = Path(other.path.path)
-        rel_path = self_path.relative_to(other_path)
-        return str(rel_path.as_posix())
-
-    def walk(
-        self, breadth_first: bool, max_depth: int = -1
-    ) -> Generator[DirListing, None, None]:
-        """List files and directories in the given path."""
-        from rclone_api.detail.walk import walk
-
-        assert self.path.rclone is not None
-        return walk(self, breadth_first=breadth_first, max_depth=max_depth)
-
-    def to_json(self) -> dict:
-        """Convert the Dir to a JSON serializable dictionary."""
-        return self.path.to_json()
-
-    def __str__(self) -> str:
-        return str(self.path)
-
-    def __repr__(self) -> str:
-        data = self.path.to_json()
-        data_str = json.dumps(data)
-        return data_str
-
-    def to_string(self, include_remote: bool = True) -> str:
-        """Convert the File to a string."""
-        out = str(self.path)
-        if not include_remote:
-            _, out = out.split(":", 1)
-        return out
-
-    # / operator
-    def __truediv__(self, other: str) -> "Dir":
-        """Join the current path with another path."""
-        path = Path(self.path.path) / other
-        rpath = RPath(
-            self.path.remote,
-            str(path.as_posix()),
-            name=other,
-            size=0,
-            mime_type="inode/directory",
-            mod_time="",
-            is_dir=True,
-        )
-        rpath.set_rclone(self.path.rclone)
-        return Dir(rpath)
+import json
+from pathlib import Path
+from typing import Generator
+
+from rclone_api.dir_listing import DirListing
+from rclone_api.remote import Remote
+from rclone_api.rpath import RPath
+from rclone_api.types import ListingOption, Order
+
+
+class Dir:
+    """Remote file dataclass."""
+
+    @property
+    def remote(self) -> Remote:
+        return self.path.remote
+
+    @property
+    def name(self) -> str:
+        return self.path.name
+
+    def __init__(self, path: RPath | Remote) -> None:
+        """Initialize Dir with either an RPath or Remote.
+
+        Args:
+            path: Either an RPath object or a Remote object
+        """
+        if isinstance(path, Remote):
+            # Need to create an RPath for the Remote's root
+            self.path = RPath(
+                remote=path,
+                path=str(path),
+                name=str(path),
+                size=0,
+                mime_type="inode/directory",
+                mod_time="",
+                is_dir=True,
+            )
+            # Ensure the RPath has the same rclone instance as the Remote
+            self.path.set_rclone(path.rclone)
+        else:
+            self.path = path
+        # self.path.set_rclone(self.path.remote.rclone)
+        assert self.path.rclone is not None
+
+    def ls(
+        self,
+        max_depth: int | None = None,
+        glob: str | None = None,
+        order: Order = Order.NORMAL,
+        listing_option: ListingOption = ListingOption.ALL,
+    ) -> DirListing:
+        """List files and directories in the given path."""
+        assert self.path.rclone is not None
+        dir = Dir(self.path)
+        return self.path.rclone.ls(
+            dir,
+            max_depth=max_depth,
+            glob=glob,
+            order=order,
+            listing_option=listing_option,
+        )
+
+    def relative_to(self, other: "Dir") -> str:
+        """Return the relative path to the other directory."""
+        self_path = Path(self.path.path)
+        other_path = Path(other.path.path)
+        rel_path = self_path.relative_to(other_path)
+        return str(rel_path.as_posix())
+
+    def walk(
+        self, breadth_first: bool, max_depth: int = -1
+    ) -> Generator[DirListing, None, None]:
+        """List files and directories in the given path."""
+        from rclone_api.detail.walk import walk
+
+        assert self.path.rclone is not None
+        return walk(self, breadth_first=breadth_first, max_depth=max_depth)
+
+    def to_json(self) -> dict:
+        """Convert the Dir to a JSON serializable dictionary."""
+        return self.path.to_json()
+
+    def __str__(self) -> str:
+        return str(self.path)
+
+    def __repr__(self) -> str:
+        data = self.path.to_json()
+        data_str = json.dumps(data)
+        return data_str
+
+    def to_string(self, include_remote: bool = True) -> str:
+        """Convert the File to a string."""
+        out = str(self.path)
+        if not include_remote:
+            _, out = out.split(":", 1)
+        return out
+
+    # / operator
+    def __truediv__(self, other: str) -> "Dir":
+        """Join the current path with another path."""
+        path = Path(self.path.path) / other
+        rpath = RPath(
+            self.path.remote,
+            str(path.as_posix()),
+            name=other,
+            size=0,
+            mime_type="inode/directory",
+            mod_time="",
+            is_dir=True,
+        )
+        rpath.set_rclone(self.path.rclone)
+        return Dir(rpath)

rclone_api/fs.py

@@ -95,9 +95,9 @@ class RemoteFS(FS):
 
     @staticmethod
     def from_rclone_config(
-        src: str, rclone_conf: Path | Config | str | None
+        src: str, rclone_conf: Path | Config | str | dict | None
     ) -> "RemoteFS":
-        if isinstance(rclone_conf, str):
+        if isinstance(rclone_conf, str) or isinstance(rclone_conf, dict):
             rclone_conf = Config(text=rclone_conf)
         return RemoteFS(rclone_conf, src)
 

rclone_api/log.py

@@ -1,44 +1,44 @@
-import logging
-import sys
-
-_INITIALISED = False
-
-
-def setup_default_logging():
-    """Set up default logging configuration if none exists."""
-    global _INITIALISED
-    if _INITIALISED:
-        return
-    if not logging.root.handlers:
-        logging.basicConfig(
-            level=logging.INFO,
-            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-            handlers=[
-                logging.StreamHandler(sys.stdout),
-                # Uncomment to add file logging
-                # logging.FileHandler('rclone_api.log')
-            ],
-        )
-
-
-def configure_logging(level=logging.INFO, log_file=None):
-    """Configure logging for the rclone_api package.
-
-    Args:
-        level: The logging level (default: logging.INFO)
-        log_file: Optional path to a log file
-    """
-    handlers = [logging.StreamHandler(sys.stdout)]
-    if log_file:
-        handlers.append(logging.FileHandler(log_file))
-
-    logging.basicConfig(
-        level=level,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-        handlers=handlers,
-        force=True,  # Override any existing configuration
-    )
-
-
-# Call setup_default_logging when this module is imported
-setup_default_logging()
+import logging
+import sys
+
+_INITIALISED = False
+
+
+def setup_default_logging():
+    """Set up default logging configuration if none exists."""
+    global _INITIALISED
+    if _INITIALISED:
+        return
+    if not logging.root.handlers:
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            handlers=[
+                logging.StreamHandler(sys.stdout),
+                # Uncomment to add file logging
+                # logging.FileHandler('rclone_api.log')
+            ],
+        )
+
+
+def configure_logging(level=logging.INFO, log_file=None):
+    """Configure logging for the rclone_api package.
+
+    Args:
+        level: The logging level (default: logging.INFO)
+        log_file: Optional path to a log file
+    """
+    handlers = [logging.StreamHandler(sys.stdout)]
+    if log_file:
+        handlers.append(logging.FileHandler(log_file))
+
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=handlers,
+        force=True,  # Override any existing configuration
+    )
+
+
+# Call setup_default_logging when this module is imported
+setup_default_logging()