rclone-api 1.0.1__tar.gz → 1.0.2__tar.gz

{rclone_api-1.0.1/src/rclone_api.egg-info → rclone_api-1.0.2}/PKG-INFO

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

{rclone_api-1.0.1 → rclone_api-1.0.2}/pyproject.toml

@@ -14,7 +14,7 @@ dependencies = [
 
 ]
 # Change this with the version number bump.
-version = "1.0.1"
+version = "1.0.2"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

rclone_api-1.0.2/src/rclone_api/__init__.py

@@ -0,0 +1,4 @@
+from .rclone import File, Rclone
+from .types import Config, Remote
+
+__all__ = ["Rclone", "File", "Config", "Remote"]

rclone_api-1.0.2/src/rclone_api/file.py

@@ -0,0 +1,77 @@
+import json
+from typing import Any
+
+
+class File:
+    """Remote file dataclass."""
+
+    def __init__(
+        self,
+        path: str,
+        name: str,
+        size: int,
+        mime_type: str,
+        mod_time: str,
+        is_dir: bool,
+    ) -> None:
+        from rclone_api.rclone import Rclone
+
+        self.path = path
+        self.name = name
+        self.size = size
+        self.mime_type = mime_type
+        self.mod_time = mod_time
+        self.is_dir = is_dir
+        self.rclone: Rclone | None = None
+
+    def set_rclone(self, rclone: Any) -> None:
+        """Set the rclone object."""
+        from rclone_api.rclone import Rclone
+
+        assert isinstance(rclone, Rclone)
+        self.rclone = rclone
+
+    @staticmethod
+    def from_dict(data: dict) -> "File":
+        """Create a File from a dictionary."""
+        return File(
+            data["Path"],
+            data["Name"],
+            data["Size"],
+            data["MimeType"],
+            data["ModTime"],
+            data["IsDir"],
+            # data["IsBucket"],
+        )
+
+    @staticmethod
+    def from_array(data: list[dict]) -> list["File"]:
+        """Create a File from a dictionary."""
+        out: list[File] = []
+        for d in data:
+            file: File = File.from_dict(d)
+            out.append(file)
+        return out
+
+    @staticmethod
+    def from_json_str(json_str: str) -> list["File"]:
+        """Create a File from a JSON string."""
+        json_obj = json.loads(json_str)
+        if isinstance(json_obj, dict):
+            return [File.from_dict(json_obj)]
+        return File.from_array(json_obj)
+
+    def to_json(self) -> dict:
+        return {
+            "Path": self.path,
+            "Name": self.name,
+            "Size": self.size,
+            "MimeType": self.mime_type,
+            "ModTime": self.mod_time,
+            "IsDir": self.is_dir,
+            # "IsBucket": self.is_bucket,
+        }
+
+    def __str__(self) -> str:
+        out = self.to_json()
+        return json.dumps(out)

rclone_api-1.0.2/src/rclone_api/rclone.py

@@ -0,0 +1,43 @@
+"""
+Unit test file.
+"""
+
+import subprocess
+from pathlib import Path
+
+from rclone_api.file import File
+from rclone_api.types import Config, RcloneExec, Remote
+from rclone_api.util import get_rclone_exe
+
+
+class Rclone:
+    def __init__(
+        self, rclone_conf: Path | Config, rclone_exe: Path | None = None
+    ) -> None:
+        if isinstance(rclone_conf, Path):
+            if not rclone_conf.exists():
+                raise ValueError(f"Rclone config file not found: {rclone_conf}")
+        self._exec = RcloneExec(rclone_conf, get_rclone_exe(rclone_exe))
+
+    def _run(self, cmd: list[str]) -> subprocess.CompletedProcess:
+        return self._exec.execute(cmd)
+
+    def ls(self, path: str | Remote) -> list[File]:
+        cmd = ["lsjson", str(path)]
+        cp = self._run(cmd)
+        text = cp.stdout
+        out: list[File] = File.from_json_str(text)
+        for o in out:
+            o.set_rclone(self)
+        return out
+
+    def listremotes(self) -> list[Remote]:
+        cmd = ["listremotes"]
+        cp = self._run(cmd)
+        text: str = cp.stdout
+        tmp = text.splitlines()
+        tmp = [t.strip() for t in tmp]
+        # strip out ":" from the end
+        tmp = [t.replace(":", "") for t in tmp]
+        out = [Remote(name=t) for t in tmp]
+        return out

rclone_api-1.0.2/src/rclone_api/types.py

@@ -0,0 +1,34 @@
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class Config:
+    """Rclone configuration dataclass."""
+
+    text: str
+
+
+@dataclass
+class RcloneExec:
+    """Rclone execution dataclass."""
+
+    rclone_config: Path | Config
+    rclone_exe: Path
+
+    def execute(self, cmd: list[str]) -> subprocess.CompletedProcess:
+        """Execute rclone command."""
+        from rclone_api.util import rclone_execute
+
+        return rclone_execute(cmd, self.rclone_config, self.rclone_exe)
+
+
+class Remote:
+    """Remote dataclass."""
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def __str__(self) -> str:
+        return f"{self.name}:"

rclone_api-1.0.2/src/rclone_api/util.py

@@ -0,0 +1,49 @@
+import shutil
+import subprocess
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from rclone_api.types import Config
+
+
+def get_rclone_exe(rclone_exe: Path | None) -> Path:
+    if rclone_exe is None:
+
+        rclone_which_path = shutil.which("rclone")
+        if rclone_which_path is None:
+            raise ValueError("rclone executable not found")
+        return Path(rclone_which_path)
+    return rclone_exe
+
+
+def rclone_execute(
+    cmd: list[str],
+    rclone_conf: Path | Config,
+    rclone_exe: Path,
+    verbose: bool = False,
+) -> subprocess.CompletedProcess:
+    print(subprocess.list2cmdline(cmd))
+    tempdir: TemporaryDirectory | None = None
+
+    try:
+        if isinstance(rclone_conf, Config):
+            tempdir = TemporaryDirectory()
+            tmpfile = Path(tempdir.name) / "rclone.conf"
+            tmpfile.write_text(rclone_conf.text, encoding="utf-8")
+            rclone_conf = tmpfile
+        cmd = (
+            [str(rclone_exe.resolve())] + ["--config", str(rclone_conf.resolve())] + cmd
+        )
+        if verbose:
+            cmd_str = subprocess.list2cmdline(cmd)
+            print(f"Running: {cmd_str}")
+        cp = subprocess.run(
+            cmd, capture_output=True, encoding="utf-8", check=True, shell=False
+        )
+        return cp
+    finally:
+        if tempdir:
+            try:
+                tempdir.cleanup()
+            except Exception as e:
+                print(f"Error cleaning up tempdir: {e}")

{rclone_api-1.0.1 → rclone_api-1.0.2/src/rclone_api.egg-info}/PKG-INFO

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

{rclone_api-1.0.1 → rclone_api-1.0.2}/src/rclone_api.egg-info/SOURCES.txt

@@ -17,7 +17,10 @@ upload_package.sh
 .vscode/tasks.json
 src/rclone_api/__init__.py
 src/rclone_api/cli.py
+src/rclone_api/file.py
 src/rclone_api/rclone.py
+src/rclone_api/types.py
+src/rclone_api/util.py
 src/rclone_api.egg-info/PKG-INFO
 src/rclone_api.egg-info/SOURCES.txt
 src/rclone_api.egg-info/dependency_links.txt

rclone_api-1.0.1/src/rclone_api/__init__.py

@@ -1,3 +0,0 @@
-from .rclone import Rclone, RcloneConfig, RemoteFile
-
-__all__ = ["Rclone", "RemoteFile", "RcloneConfig"]

rclone_api-1.0.1/src/rclone_api/rclone.py

@@ -1,160 +0,0 @@
-"""
-Unit test file.
-"""
-
-import json
-import shutil
-import subprocess
-from dataclasses import dataclass
-from pathlib import Path
-from tempfile import TemporaryDirectory
-
-
-@dataclass
-class RcloneConfig:
-    """Rclone configuration dataclass."""
-
-    text: str
-
-
-def _rclone_execute(
-    cmd: list[str],
-    rclone_conf: Path | RcloneConfig,
-    rclone_exe: Path,
-    verbose: bool = False,
-) -> subprocess.CompletedProcess:
-    print(subprocess.list2cmdline(cmd))
-    tempdir: TemporaryDirectory | None = None
-
-    try:
-        if isinstance(rclone_conf, RcloneConfig):
-            tempdir = TemporaryDirectory()
-            tmpfile = Path(tempdir.name) / "rclone.conf"
-            tmpfile.write_text(rclone_conf.text, encoding="utf-8")
-            rclone_conf = tmpfile
-        cmd = (
-            [str(rclone_exe.resolve())] + ["--config", str(rclone_conf.resolve())] + cmd
-        )
-        if verbose:
-            cmd_str = subprocess.list2cmdline(cmd)
-            print(f"Running: {cmd_str}")
-        cp = subprocess.run(
-            cmd, capture_output=True, encoding="utf-8", check=True, shell=False
-        )
-        return cp
-    finally:
-        if tempdir:
-            try:
-                tempdir.cleanup()
-            except Exception as e:
-                print(f"Error cleaning up tempdir: {e}")
-
-
-@dataclass
-class RcloneExec:
-    """Rclone execution dataclass."""
-
-    rclone_config: Path | RcloneConfig
-    rclone_exe: Path
-
-    def execute(self, cmd: list[str]) -> subprocess.CompletedProcess:
-        """Execute rclone command."""
-        return _rclone_execute(cmd, self.rclone_config, self.rclone_exe)
-
-
-@dataclass
-class RemoteFile:
-    """Remote file dataclass."""
-
-    path: str
-    name: str
-    size: int
-    mime_type: str
-    mod_time: str
-    is_dir: bool
-    # is_bucket: bool
-
-    @staticmethod
-    def from_dict(data: dict) -> "RemoteFile":
-        """Create a RemoteFile from a dictionary."""
-        return RemoteFile(
-            data["Path"],
-            data["Name"],
-            data["Size"],
-            data["MimeType"],
-            data["ModTime"],
-            data["IsDir"],
-            # data["IsBucket"],
-        )
-
-    @staticmethod
-    def from_array(data: list[dict]) -> list["RemoteFile"]:
-        """Create a RemoteFile from a dictionary."""
-        out: list[RemoteFile] = []
-        for d in data:
-            file: RemoteFile = RemoteFile.from_dict(d)
-            out.append(file)
-        return out
-
-    @staticmethod
-    def from_json_str(json_str: str) -> list["RemoteFile"]:
-        """Create a RemoteFile from a JSON string."""
-        json_obj = json.loads(json_str)
-        if isinstance(json_obj, dict):
-            return [RemoteFile.from_dict(json_obj)]
-        return RemoteFile.from_array(json_obj)
-
-    def to_json(self) -> dict:
-        return {
-            "Path": self.path,
-            "Name": self.name,
-            "Size": self.size,
-            "MimeType": self.mime_type,
-            "ModTime": self.mod_time,
-            "IsDir": self.is_dir,
-            # "IsBucket": self.is_bucket,
-        }
-
-    def __str__(self) -> str:
-        out = self.to_json()
-        return json.dumps(out)
-
-
-def _get_rclone_exe(rclone_exe: Path | None) -> Path:
-    if rclone_exe is None:
-
-        rclone_which_path = shutil.which("rclone")
-        if rclone_which_path is None:
-            raise ValueError("rclone executable not found")
-        return Path(rclone_which_path)
-    return rclone_exe
-
-
-class Rclone:
-    def __init__(
-        self, rclone_conf: Path | RcloneConfig, rclone_exe: Path | None = None
-    ) -> None:
-        if isinstance(rclone_conf, Path):
-            if not rclone_conf.exists():
-                raise ValueError(f"Rclone config file not found: {rclone_conf}")
-        self._exec = RcloneExec(rclone_conf, _get_rclone_exe(rclone_exe))
-
-    def _run(self, cmd: list[str]) -> subprocess.CompletedProcess:
-        return self._exec.execute(cmd)
-
-    def ls(self, path: str) -> list[RemoteFile]:
-        cmd = ["lsjson", path]
-        cp = self._run(cmd)
-        text = cp.stdout
-        out: list[RemoteFile] = RemoteFile.from_json_str(text)
-        return out
-
-    def listremotes(self) -> list[str]:
-        cmd = ["listremotes"]
-        cp = self._run(cmd)
-        text = cp.stdout
-        out = text.splitlines()
-        out = [o.strip() for o in out]
-        # strip out ":" from the end
-        out = [o.replace(":", "") for o in out]
-        return out