rclone-api 1.5.37__py3-none-any.whl → 1.5.39__py3-none-any.whl

rclone_api/config.py

@@ -1,153 +1,186 @@
-import os
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Dict, List
-
-
-@dataclass
-class Section:
-    name: str
-    data: Dict[str, str] = field(default_factory=dict)
-
-    def add(self, key: str, value: str) -> None:
-        self.data[key] = value
-
-    def type(self) -> str:
-        return self.data["type"]
-
-    def provider(self) -> str | None:
-        return self.data.get("provider")
-
-    def access_key_id(self) -> str:
-        if "access_key_id" in self.data:
-            return self.data["access_key_id"]
-        elif "account" in self.data:
-            return self.data["account"]
-        raise KeyError("No access key found")
-
-    def secret_access_key(self) -> str:
-        # return self.data["secret_access_key"]
-        if "secret_access_key" in self.data:
-            return self.data["secret_access_key"]
-        elif "key" in self.data:
-            return self.data["key"]
-        raise KeyError("No secret access key found")
-
-    def endpoint(self) -> str | None:
-        return self.data.get("endpoint")
-
-
-@dataclass
-class Parsed:
-    # sections: List[ParsedSection]
-    sections: dict[str, Section]
-
-    @staticmethod
-    def parse(content: str) -> "Parsed":
-        return parse_rclone_config(content)
-
-
-@dataclass
-class Config:
-    """Rclone configuration dataclass."""
-
-    text: str
-
-    def parse(self) -> Parsed:
-        return Parsed.parse(self.text)
-
-
-def find_conf_file(rclone: Any | None = None) -> Path | None:
-    import subprocess
-
-    from rclone_api import Rclone
-    from rclone_api.rclone_impl import RcloneImpl
-
-    # if os.environ.get("RCLONE_CONFIG"):
-    #     return Path(os.environ["RCLONE_CONFIG"])
-    # return None
-    # rclone_conf = rclone_conf or Path.cwd() / "rclone.conf"
-
-    if os.environ.get("RCLONE_CONFIG"):
-        return Path(os.environ["RCLONE_CONFIG"])
-    if (conf := Path.cwd() / "rclone.conf").exists():
-        return conf
-
-    if rclone is None:
-        from rclone_api.install import rclone_download
-
-        err = rclone_download(Path("."))
-        if isinstance(err, Exception):
-            import warnings
-
-            warnings.warn(f"rclone_download failed: {err}")
-            return None
-        cmd_list: list[str] = [
-            "rclone",
-            "config",
-            "paths",
-        ]
-        subproc: subprocess.CompletedProcess = subprocess.run(
-            args=cmd_list,
-            shell=True,
-            capture_output=True,
-            text=True,
-        )
-        if subproc.returncode == 0:
-            stdout = subproc.stdout
-            for line in stdout.splitlines():
-                parts = line.split(":", 1)
-                if len(parts) == 2:
-                    _, value = parts
-                    value = value.strip()
-                    value_path = Path(value.strip())
-                    if value_path.exists():
-                        return value_path
-    else:
-        if isinstance(rclone, Rclone):
-            rclone = rclone.impl
-        else:
-            assert isinstance(rclone, RcloneImpl)
-        rclone_impl: RcloneImpl = rclone
-        assert isinstance(rclone_impl, RcloneImpl)
-        paths_or_err = rclone_impl.config_paths()
-        if isinstance(paths_or_err, Exception):
-            return None
-        paths = paths_or_err
-        path: Path
-        for path in paths:
-            if path.exists():
-                return path
-    return None
-
-
-def parse_rclone_config(content: str) -> Parsed:
-    """
-    Parses an rclone configuration file and returns a list of RcloneConfigSection objects.
-
-    Each section in the file starts with a line like [section_name]
-    followed by key=value pairs.
-    """
-    sections: List[Section] = []
-    current_section: Section | None = None
-
-    lines = content.splitlines()
-    for line in lines:
-        line = line.strip()
-        # Skip empty lines and comments (assumed to start with '#' or ';')
-        if not line or line.startswith(("#", ";")):
-            continue
-        # New section header detected
-        if line.startswith("[") and line.endswith("]"):
-            section_name = line[1:-1].strip()
-            current_section = Section(name=section_name)
-            sections.append(current_section)
-        elif "=" in line and current_section is not None:
-            # Parse key and value, splitting only on the first '=' found
-            key, value = line.split("=", 1)
-            current_section.add(key.strip(), value.strip())
-
-    data: dict[str, Section] = {}
-    for section in sections:
-        data[section.name] = section
-    return Parsed(sections=data)
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+@dataclass
+class Section:
+    name: str
+    data: Dict[str, str] = field(default_factory=dict)
+
+    def add(self, key: str, value: str) -> None:
+        self.data[key] = value
+
+    def type(self) -> str:
+        return self.data["type"]
+
+    def provider(self) -> str | None:
+        return self.data.get("provider")
+
+    def access_key_id(self) -> str:
+        if "access_key_id" in self.data:
+            return self.data["access_key_id"]
+        elif "account" in self.data:
+            return self.data["account"]
+        raise KeyError("No access key found")
+
+    def secret_access_key(self) -> str:
+        # return self.data["secret_access_key"]
+        if "secret_access_key" in self.data:
+            return self.data["secret_access_key"]
+        elif "key" in self.data:
+            return self.data["key"]
+        raise KeyError("No secret access key found")
+
+    def endpoint(self) -> str | None:
+        return self.data.get("endpoint")
+
+
+@dataclass
+class Parsed:
+    # sections: List[ParsedSection]
+    sections: dict[str, Section]
+
+    @staticmethod
+    def parse(content: str) -> "Parsed":
+        return parse_rclone_config(content)
+
+
+@dataclass
+class Config:
+    """Rclone configuration dataclass."""
+
+    text: str
+
+    @staticmethod
+    def from_json(json_data: dict) -> "Config | Exception":
+        return json_to_rclone_config(json_data)
+
+    def parse(self) -> Parsed:
+        return Parsed.parse(self.text)
+
+
+def find_conf_file(rclone: Any | None = None) -> Path | None:
+    import subprocess
+
+    from rclone_api import Rclone
+    from rclone_api.rclone_impl import RcloneImpl
+
+    # if os.environ.get("RCLONE_CONFIG"):
+    #     return Path(os.environ["RCLONE_CONFIG"])
+    # return None
+    # rclone_conf = rclone_conf or Path.cwd() / "rclone.conf"
+
+    if os.environ.get("RCLONE_CONFIG"):
+        return Path(os.environ["RCLONE_CONFIG"])
+    if (conf := Path.cwd() / "rclone.conf").exists():
+        return conf
+
+    if rclone is None:
+        from rclone_api.install import rclone_download
+
+        err = rclone_download(Path("."))
+        if isinstance(err, Exception):
+            import warnings
+
+            warnings.warn(f"rclone_download failed: {err}")
+            return None
+        cmd_list: list[str] = [
+            "rclone",
+            "config",
+            "paths",
+        ]
+        subproc: subprocess.CompletedProcess = subprocess.run(
+            args=cmd_list,
+            shell=True,
+            capture_output=True,
+            text=True,
+        )
+        if subproc.returncode == 0:
+            stdout = subproc.stdout
+            for line in stdout.splitlines():
+                parts = line.split(":", 1)
+                if len(parts) == 2:
+                    _, value = parts
+                    value = value.strip()
+                    value_path = Path(value.strip())
+                    if value_path.exists():
+                        return value_path
+    else:
+        if isinstance(rclone, Rclone):
+            rclone = rclone.impl
+        else:
+            assert isinstance(rclone, RcloneImpl)
+        rclone_impl: RcloneImpl = rclone
+        assert isinstance(rclone_impl, RcloneImpl)
+        paths_or_err = rclone_impl.config_paths()
+        if isinstance(paths_or_err, Exception):
+            return None
+        paths = paths_or_err
+        path: Path
+        for path in paths:
+            if path.exists():
+                return path
+    return None
+
+
+def parse_rclone_config(content: str) -> Parsed:
+    """
+    Parses an rclone configuration file and returns a list of RcloneConfigSection objects.
+
+    Each section in the file starts with a line like [section_name]
+    followed by key=value pairs.
+    """
+    sections: List[Section] = []
+    current_section: Section | None = None
+
+    lines = content.splitlines()
+    for line in lines:
+        line = line.strip()
+        # Skip empty lines and comments (assumed to start with '#' or ';')
+        if not line or line.startswith(("#", ";")):
+            continue
+        # New section header detected
+        if line.startswith("[") and line.endswith("]"):
+            section_name = line[1:-1].strip()
+            current_section = Section(name=section_name)
+            sections.append(current_section)
+        elif "=" in line and current_section is not None:
+            # Parse key and value, splitting only on the first '=' found
+            key, value = line.split("=", 1)
+            current_section.add(key.strip(), value.strip())
+
+    data: dict[str, Section] = {}
+    for section in sections:
+        data[section.name] = section
+    return Parsed(sections=data)
+
+
+# JSON_DATA = {
+#     "dst": {
+#         "type": "s3",
+#         "bucket": "bucket",
+#         "endpoint": "https://s3.amazonaws.com",
+#         "access_key_id": "access key",
+#         "access_secret_key": "access secret key",
+#     }
+# }
+
+
+def _json_to_rclone_config_str_or_raise(json_data: dict) -> str:
+    """Convert JSON data to rclone config."""
+    out = ""
+    for key, value in json_data.items():
+        out += f"[{key}]\n"
+        for k, v in value.items():
+            out += f"{k} = {v}\n"
+    return out
+
+
+def json_to_rclone_config(json_data: dict) -> Config | Exception:
+    try:
+        text = _json_to_rclone_config_str_or_raise(json_data)
+        return Config(text=text)
+    except Exception as e:
+        return e

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