rclone-api 1.3.7__py2.py3-none-any.whl → 1.3.8__py2.py3-none-any.whl

rclone_api/cmd/analyze.py

@@ -0,0 +1,51 @@
+import argparse
+from dataclasses import dataclass
+from pathlib import Path
+
+from rclone_api import Rclone
+
+
+@dataclass
+class Args:
+    config: Path
+    path: str
+
+    def __post_init__(self):
+        if not self.config.exists():
+            raise FileNotFoundError(f"Config file not found: {self.config}")
+
+
+def list_files(rclone: Rclone, path: str):
+    """List files in a remote path."""
+
+    with rclone.ls_stream(path, fast_list=True) as files:
+        for file_item in files:
+            print(file_item.path, "", file_item.size, file_item.mod_time)
+
+
+def _parse_args() -> Args:
+    parser = argparse.ArgumentParser(description="List files in a remote path.")
+    parser.add_argument(
+        "--config", help="Path to rclone config file", type=Path, default="rclone.conf"
+    )
+    parser.add_argument("path", help="Remote path to list")
+    tmp = parser.parse_args()
+    return Args(config=tmp.config, path=tmp.path)
+
+
+def main() -> int:
+    """Main entry point."""
+    args = _parse_args()
+    path = args.path
+    rclone = Rclone(Path(args.config))
+    list_files(rclone, path)
+    return 0
+
+
+if __name__ == "__main__":
+    import sys
+
+    cwd = Path(".").absolute()
+    print(f"cwd: {cwd}")
+    sys.argv.append("dst:TorrentBooks")
+    main()

rclone_api/cmd/fill_db.py

@@ -0,0 +1,68 @@
+import argparse
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from rclone_api import Rclone
+
+# load_dotenv()
+
+
+# DB_URL = "sqlite:///data.db"
+
+# os.environ["DB_URL"] = "sqlite:///data.db"
+
+
+def _db_url_from_env_or_raise() -> str:
+    load_dotenv()
+    db_url = os.getenv("DB_URL")
+    if db_url is None:
+        raise ValueError("DB_URL not set")
+    return db_url
+
+
+@dataclass
+class Args:
+    config: Path
+    path: str
+
+    def __post_init__(self):
+        if not self.config.exists():
+            raise FileNotFoundError(f"Config file not found: {self.config}")
+
+
+def fill_db(rclone: Rclone, path: str):
+    """List files in a remote path."""
+    # db = DB(_db_url_from_env_or_raise())
+    db_url = _db_url_from_env_or_raise()
+    rclone.save_to_db(src=path, db_url=db_url, fast_list=True)
+
+
+def _parse_args() -> Args:
+    parser = argparse.ArgumentParser(description="List files in a remote path.")
+    parser.add_argument(
+        "--config", help="Path to rclone config file", type=Path, default="rclone.conf"
+    )
+    parser.add_argument("path", help="Remote path to list")
+    tmp = parser.parse_args()
+    return Args(config=tmp.config, path=tmp.path)
+
+
+def main() -> int:
+    """Main entry point."""
+    args = _parse_args()
+    path = args.path
+    rclone = Rclone(Path(args.config))
+    fill_db(rclone, path)
+    return 0
+
+
+if __name__ == "__main__":
+    import sys
+
+    cwd = Path(".").absolute()
+    print(f"cwd: {cwd}")
+    sys.argv.append("dst:TorrentBooks/meta")
+    main()

rclone_api/db/__init__.py

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

rclone_api/db/db.py

@@ -0,0 +1,268 @@
+"""
+Database module for rclone_api.
+"""
+
+import os
+from threading import Lock
+from typing import Optional
+
+from sqlmodel import Session, SQLModel, create_engine, select
+
+from rclone_api.db.models import RepositoryMeta, create_file_entry_model
+from rclone_api.file import FileItem
+
+
+def _to_table_name(remote_name: str) -> str:
+    return (
+        "files_"
+        + remote_name.replace(":", "_").replace(" ", "_").replace("/", "_").lower()
+    )
+
+
+class DB:
+    """Database class for rclone_api."""
+
+    def __init__(self, db_path_url: str):
+        """Initialize the database.
+
+        Args:
+            db_path: Path to the database file
+        """
+        self.db_path_url = db_path_url
+        self.engine = create_engine(db_path_url)
+
+        # Create the meta table
+        SQLModel.metadata.create_all(self.engine)
+        self._cache: dict[str, DBRepo] = {}
+        self._cache_lock = Lock()
+
+    def drop_all(self) -> None:
+        """Drop all tables in the database."""
+        SQLModel.metadata.drop_all(self.engine)
+
+    def close(self) -> None:
+        """Close the database connection and release resources."""
+        if hasattr(self, "engine") and self.engine is not None:
+            self.engine.dispose()
+
+    def add_files(self, files: list[FileItem]) -> None:
+        """Add files to the database.
+
+        Args:
+            remote_name: Name of the remote
+            files: List of file entries
+        """
+
+        partition: dict[str, list[FileItem]] = {}
+        for file in files:
+            partition.setdefault(file.remote, []).append(file)
+
+        for remote_name, files in partition.items():
+            repo = self.get_or_create_repo(remote_name)
+            repo.insert_files(files)
+
+    def query_files(self, remote_name: str) -> list[FileItem]:
+        """Query files from the database.
+
+        Args:
+            remote_name: Name of the remote
+        """
+        repo = self.get_or_create_repo(remote_name)
+        files = repo.get_files()
+        out: list[FileItem] = []
+        for file in files:
+            out.append(file)
+        return out
+
+    def get_or_create_repo(self, remote_name: str) -> "DBRepo":
+        """Get a table section for a remote.
+
+        Args:
+            remote_name: Name of the remote
+            table_name: Optional table name, will be derived from remote_name if not provided
+
+        Returns:
+            DBRepo: A table section for the remote
+        """
+        with self._cache_lock:
+            if remote_name in self._cache:
+                return self._cache[remote_name]
+            table_name = _to_table_name(remote_name)
+            out = DBRepo(self.engine, remote_name, table_name)
+            self._cache[remote_name] = out
+            return out
+
+
+class DBRepo:
+    """Table repo remote."""
+
+    def __init__(self, engine, remote_name: str, table_name: Optional[str] = None):
+        """Initialize a table section.
+
+        Args:
+            engine: SQLAlchemy engine
+            remote_name: Name of the remote
+            table_name: Optional table name, will be derived from remote_name if not provided
+        """
+        self.engine = engine
+        self.remote_name = remote_name
+
+        # If table_name is not provided, derive one from the remote name.
+        if table_name is None:
+            # table_name = (
+            #     "file_entries_"
+            #     + remote_name.replace(":", "_").replace(" ", "_").replace("/", "_").lower()
+            # )
+            table_name = _to_table_name(remote_name)
+        self.table_name = table_name
+
+        # Check if repository exists in RepositoryMeta; if not, create a new entry.
+        with Session(self.engine) as session:
+            existing_repo = session.exec(
+                select(RepositoryMeta).where(
+                    RepositoryMeta.repo_name == self.remote_name
+                )
+            ).first()
+            if not existing_repo:
+                repo_meta = RepositoryMeta(
+                    repo_name=self.remote_name, file_table_name=self.table_name
+                )
+                session.add(repo_meta)
+                session.commit()
+
+        # Dynamically create the file entry model and its table.
+        self.FileEntryModel = create_file_entry_model(self.table_name)
+        SQLModel.metadata.create_all(self.engine, tables=[self.FileEntryModel.__table__])  # type: ignore
+
+    def insert_file(self, file: FileItem) -> None:
+        """Insert a file entry into the table.
+
+        Args:
+            file: File entry
+        """
+        return self.insert_files([file])
+
+    def insert_files(self, files: list[FileItem]) -> None:
+        """
+        Insert multiple file entries into the table.
+
+        Three bulk operations are performed:
+        1. Select: Determine which files already exist.
+        2. Insert: Bulk-insert new file entries.
+        3. Update: Bulk-update existing file entries.
+
+        The FileEntryModel must define a unique constraint on (path, name) and have a primary key "id".
+        """
+        # Step 1: Bulk select existing records.
+        # get_exists() returns a set of FileItem objects (based on path_no_remote and name) that already exist.
+        existing_files = self.get_exists(files)
+
+        # Determine which files need to be updated vs. inserted.
+        needs_update = existing_files
+        is_new = set(files) - existing_files
+
+        # Step 2: Bulk insert new rows.
+        new_values = [
+            {
+                "path": file.path_no_remote,
+                "name": file.name,
+                "size": file.size,
+                "mime_type": file.mime_type,
+                "mod_time": file.mod_time,
+                "suffix": file.suffix,
+            }
+            for file in is_new
+        ]
+        with Session(self.engine) as session:
+            if new_values:
+                session.bulk_insert_mappings(self.FileEntryModel, new_values)  # type: ignore
+                session.commit()
+
+        # Step 3: Bulk update existing rows.
+        # First, query the database for the primary keys of rows that match the unique keys in needs_update.
+        with Session(self.engine) as session:
+            # Collect all unique paths from files needing update.
+            update_paths = [file.path_no_remote for file in needs_update]
+            # Query for existing rows matching any of these paths.
+            db_entries = session.exec(
+                select(self.FileEntryModel).where(
+                    self.FileEntryModel.path.in_(update_paths)  # type: ignore
+                )
+            ).all()
+
+            # Build a mapping from the unique key (path, name) to the primary key (id).
+            id_map = {(entry.path, entry.name): entry.id for entry in db_entries}
+
+            # Prepare bulk update mappings.
+            update_values = []
+            for file in needs_update:
+                key = (file.path_no_remote, file.name)
+                if key in id_map:
+                    update_values.append(
+                        {
+                            "id": id_map[key],
+                            "size": file.size,
+                            "mime_type": file.mime_type,
+                            "mod_time": file.mod_time,
+                            "suffix": file.suffix,
+                        }
+                    )
+            if update_values:
+                session.bulk_update_mappings(self.FileEntryModel, update_values)  # type: ignore
+                session.commit()
+
+    def get_exists(self, files: list[FileItem]) -> set[FileItem]:
+        """Get file entries from the table that exist among the given files.
+
+        Args:
+            files: List of file entries
+
+        Returns:
+            Set of FileItem instances whose 'path_no_remote' exists in the table.
+        """
+        # Extract unique paths from the input files.
+        paths = {file.path_no_remote for file in files}
+
+        with Session(self.engine) as session:
+            # Execute a single query to fetch all file paths in the table that match the input paths.
+            result = session.exec(
+                select(self.FileEntryModel.path).where(
+                    self.FileEntryModel.path.in_(paths)  # type: ignore
+                )
+            ).all()
+            # Convert the result to a set for fast membership tests.
+            existing_paths = set(result)
+
+        # Return the set of FileItem objects that have a path in the existing_paths.
+        return {file for file in files if file.path_no_remote in existing_paths}
+
+    def get_files(self) -> list[FileItem]:
+        """Get all files in the table.
+
+        Returns:
+            list: List of file entries
+        """
+        # with Session(self.engine) as session:
+        #     return session.exec(select(self.FileEntryModel)).all()
+        out: list[FileItem] = []
+        with Session(self.engine) as session:
+            query = session.exec(select(self.FileEntryModel)).all()
+            for item in query:
+                name = item.name  # type: ignore
+                size = item.size  # type: ignore
+                mime_type = item.mime_type  # type: ignore
+                mod_time = item.mod_time  # type: ignore
+                path = item.path  # type: ignore
+                parent = os.path.dirname(path)
+                if parent == "/" or parent == ".":
+                    parent = ""
+                o = FileItem(
+                    remote=self.remote_name,
+                    parent=parent,
+                    name=name,
+                    size=size,
+                    mime_type=mime_type,
+                    mod_time=mod_time,
+                )
+                out.append(o)
+        return out

rclone_api/db/models.py

@@ -0,0 +1,57 @@
+"""
+Database models for rclone_api.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Type
+
+from sqlalchemy import BigInteger, Column
+from sqlmodel import Field, SQLModel
+
+
+# Meta table that indexes all repositories
+class RepositoryMeta(SQLModel, table=True):
+    """Repository metadata table."""
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+    repo_name: str
+    file_table_name: str  # The dedicated table name for file entries
+
+
+# Base FileEntry model that will be extended
+class FileEntry(SQLModel, ABC):
+    """Base file entry model with common fields."""
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+    path: str = Field(index=True, unique=True)
+    suffix: str = Field(index=True)
+    name: str
+    size: int = Field(sa_column=Column(BigInteger))
+    mime_type: str
+    mod_time: str
+    hash: Optional[str] = Field(default=None)
+
+    @abstractmethod
+    def table_name(self) -> str:
+        """Return the table name for this file entry model."""
+        pass
+
+
+# Factory to dynamically create a FileEntry model with a given table name
+def create_file_entry_model(_table_name: str) -> Type[FileEntry]:
+    """Create a file entry model with a given table name.
+
+    Args:
+        table_name: Table name
+
+    Returns:
+        Type[FileEntryBase]: File entry model class with specified table name
+    """
+
+    class FileEntryConcrete(FileEntry, table=True):
+        __tablename__ = _table_name  # type: ignore # dynamically set table name
+
+        def table_name(self) -> str:
+            return _table_name
+
+    return FileEntryConcrete

rclone_api/file.py

@@ -5,41 +5,85 @@ from pathlib import Path
 
 from rclone_api.rpath import RPath
 
+_STRING_INTERNER: dict[str, str] = {}
+
+
+def _intern(s: str) -> str:
+    return _STRING_INTERNER.setdefault(s, s)
+
 
 # File is too complex, this is a simple dataclass that can be streamed out.
 @dataclass
 class FileItem:
     """Remote file dataclass."""
 
-    path: str
+    remote: str
+    parent: str
     name: str
     size: int
     mime_type: str
     mod_time: str
+    hash: str | None = None
+
+    @property
+    def path(self) -> str:
+        if self.parent == ".":
+            return f"{self.remote}/{self.name}"
+        else:
+            return f"{self.remote}/{self.parent}/{self.name}"
+
+    @property
+    def path_no_remote(self) -> str:
+        if self.parent == ".":
+            return f"{self.name}"
+        else:
+            return f"{self.parent}/{self.name}"
+
+    @property
+    def suffix(self) -> str:
+        return self._suffix
+
+    def __post_init__(self):
+        self.parent = _intern(self.parent)
+        self.mime_type = _intern(self.mime_type)
+        self.remote = _intern(self.remote)
+        self._suffix = _intern(Path(self.name).suffix)
 
     @staticmethod
-    def from_json(data: dict) -> "FileItem | None":
+    def from_json(remote: str, data: dict) -> "FileItem | None":
         try:
+            path_str: str = data["Path"]
+            parent_path = Path(path_str).parent.as_posix()
+            name = data["Name"]
+            size = data["Size"]
+            mime_type = data["MimeType"]
+            mod_time = data["ModTime"]
+
             return FileItem(
-                data["Path"],
-                data["Name"],
-                data["Size"],
-                data["MimeType"],
-                data["ModTime"],
+                remote=remote,
+                parent=parent_path,
+                name=name,
+                size=size,
+                mime_type=mime_type,
+                mod_time=mod_time,
             )
         except KeyError:
             warnings.warn(f"Invalid data: {data}")
             return None
 
     @staticmethod
-    def from_json_str(data: str) -> "FileItem | None":
+    def from_json_str(remote: str, data: str) -> "FileItem | None":
         try:
             data_dict = json.loads(data)
-            return FileItem.from_json(data_dict)
+            return FileItem.from_json(remote, data_dict)
         except json.JSONDecodeError:
             warnings.warn(f"Invalid JSON data: {data}")
             return None
 
+    # hasher for set membership
+    def __hash__(self) -> int:
+        return hash(self.path_no_remote)
+
 
 class File:
     """Remote file dataclass."""

rclone_api/file_item.py

@@ -0,0 +1,68 @@
+import json
+import warnings
+from dataclasses import dataclass
+from pathlib import Path
+
+_STRING_INTERNER: dict[str, str] = {}
+
+
+def _intern(s: str) -> str:
+    return _STRING_INTERNER.setdefault(s, s)
+
+
+# File is too complex, this is a simple dataclass that can be streamed out.
+@dataclass
+class FileItem:
+    """Remote file dataclass."""
+
+    remote: str
+    parent: str
+    name: str
+    size: int
+    mime_type: str
+    mod_time: str
+
+    @property
+    def path(self) -> str:
+        return f"{self.remote}/{self.parent}/{self.name}"
+
+    @property
+    def suffix(self) -> str:
+        return self._suffix
+
+    def __post_init__(self):
+        self.parent = _intern(self.parent)
+        self.mime_type = _intern(self.mime_type)
+        suffix = Path(self.name).suffix
+        self._suffix = _intern(suffix)
+
+    @staticmethod
+    def from_json(data: dict) -> "FileItem | None":
+        try:
+            path_str: str = data["Path"]
+            parent_path = Path(path_str).parent.as_posix()
+            name = data["Name"]
+            size = data["Size"]
+            mime_type = data["MimeType"]
+            mod_time = data["ModTime"]
+
+            return FileItem(
+                remote="DUMMY",
+                parent=parent_path,
+                name=name,
+                size=size,
+                mime_type=mime_type,
+                mod_time=mod_time,
+            )
+        except KeyError:
+            warnings.warn(f"Invalid data: {data}")
+            return None
+
+    @staticmethod
+    def from_json_str(data: str) -> "FileItem | None":
+        try:
+            data_dict = json.loads(data)
+            return FileItem.from_json(data_dict)
+        except json.JSONDecodeError:
+            warnings.warn(f"Invalid JSON data: {data}")
+            return None

rclone_api/process.py

@@ -76,6 +76,8 @@ class Process:
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.terminate()
+        self.wait()
         self.cleanup()
 
     def cleanup(self) -> None:

rclone_api/rclone.py

@@ -67,6 +67,77 @@ def _to_rclone_conf(config: Config | Path) -> Config:
         return config
 
 
+# class closing(AbstractContextManager):
+#     """Context to automatically close something at the end of a block.
+
+#     Code like this:
+
+#         with closing(<module>.open(<arguments>)) as f:
+#             <block>
+
+#     is equivalent to this:
+
+#         f = <module>.open(<arguments>)
+#         try:
+#             <block>
+#         finally:
+#             f.close()
+
+#     """
+#     def __init__(self, thing):
+#         self.thing = thing
+#     def __enter__(self):
+#         return self.thing
+#     def __exit__(self, *exc_info):
+#         self.thing.close()
+
+
+# Process
+
+
+class FilesStream:
+
+    def __init__(self, path: str, process: Process) -> None:
+        self.path = path
+        self.process = process
+
+    def __enter__(self) -> "FilesStream":
+        self.process.__enter__()
+        return self
+
+    def __exit__(self, *exc_info):
+        self.process.__exit__(*exc_info)
+
+    def files(self) -> Generator[FileItem, None, None]:
+        for line in self.process.stdout:
+            linestr = line.decode("utf-8").strip()
+            if linestr.startswith("["):
+                continue
+            if linestr.endswith(","):
+                linestr = linestr[:-1]
+            if linestr.endswith("]"):
+                continue
+            fileitem: FileItem | None = FileItem.from_json_str(self.path, linestr)
+            if fileitem is None:
+                continue
+            yield fileitem
+
+    def files_paged(
+        self, page_size: int = 1000
+    ) -> Generator[list[FileItem], None, None]:
+        page: list[FileItem] = []
+        for fileitem in self.files():
+            page.append(fileitem)
+            if len(page) >= page_size:
+                yield page
+                page = []
+        if len(page) > 0:
+            yield page
+
+    def __iter__(self) -> Generator[FileItem, None, None]:
+        return self.files()
+
+
 class Rclone:
     def __init__(
         self, rclone_conf: Path | Config, rclone_exe: Path | None = None
@@ -147,12 +218,12 @@ class Rclone:
         cp = self._run(cmd_list)
         return cp.stdout.strip()
 
-    def ls_stream_files(
+    def ls_stream(
         self,
         path: str,
         max_depth: int = -1,
         fast_list: bool = False,
-    ) -> Generator[FileItem, None, None]:
+    ) -> FilesStream:
         """List files in the given path"""
         cmd = ["lsjson", path]
         if max_depth < 0:
@@ -161,19 +232,23 @@ class Rclone:
             cmd += ["--max-depth", str(max_depth)]
         if fast_list:
             cmd.append("--fast-list")
-        with self._launch_process(cmd, capture=True) as process:
-            for line in process.stdout:
-                linestr = line.decode("utf-8").strip()
-                if linestr.startswith("["):
-                    continue
-                if linestr.endswith(","):
-                    linestr = linestr[:-1]
-                if linestr.endswith("]"):
-                    continue
-                fileitem: FileItem | None = FileItem.from_json_str(linestr)
-                if fileitem is None:
-                    continue
-                yield fileitem
+        streamer = FilesStream(path, self._launch_process(cmd, capture=True))
+        return streamer
+
+    def save_to_db(
+        self,
+        src: str,
+        db_url: str,
+        max_depth: int = -1,
+        fast_list: bool = False,
+    ) -> None:
+        """Save files to a database (sqlite, mysql, postgres)"""
+        from rclone_api.db import DB
+
+        db = DB(db_url)
+        with self.ls_stream(src, max_depth, fast_list) as stream:
+            for page in stream.files_paged(page_size=10000):
+                db.add_files(page)
 
     def ls(
         self,

{rclone_api-1.3.7.dist-info → rclone_api-1.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.3.7
+Version: 1.3.8
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 License: BSD 3-Clause License
@@ -14,6 +14,8 @@ Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: certifi>=2025.1.31
 Requires-Dist: psutil
 Requires-Dist: boto3<=1.35.99,>=1.20.1
+Requires-Dist: sqlmodel>=0.0.23
+Requires-Dist: psycopg2-binary>=2.9.10
 Dynamic: home-page
 
 # rclone-api

{rclone_api-1.3.7.dist-info → rclone_api-1.3.8.dist-info}/RECORD

@@ -8,14 +8,15 @@ rclone_api/diff.py,sha256=tMoJMAGmLSE6Q_7QhPf6PnCzb840djxMZtDmhc2GlGQ,5227
 rclone_api/dir.py,sha256=i4h7LX5hB_WmVixxDRWL_l1nifvscrdWct_8Wx7wHZc,3540
 rclone_api/dir_listing.py,sha256=GoziW8Sne6FY90MLNcb2aO3aaa3jphB6H8ExYrV0Ryo,1882
 rclone_api/exec.py,sha256=Bq0gkyZ10mEY0FRyzNZgdN4FaWP9vpeCk1kjpg-gN_8,1083
-rclone_api/file.py,sha256=HdqzNpUKyOTGLb8XCgEMDAug5av5sEB3ieDow6MnPnk,2809
+rclone_api/file.py,sha256=PfjKphl_wMAzXzSShuLGTm4EW134NKPfcYDCuxYn5GY,4057
+rclone_api/file_item.py,sha256=cH-AQYsxedhNPp4c8NHY1ad4Z7St4yf_VGbmiGD59no,1770
 rclone_api/filelist.py,sha256=xbiusvNgaB_b_kQOZoHMJJxn6TWGtPrWd2J042BI28o,767
 rclone_api/group_files.py,sha256=H92xPW9lQnbNw5KbtZCl00bD6iRh9yRbCuxku4j_3dg,8036
 rclone_api/log.py,sha256=VZHM7pNSXip2ZLBKMP7M1u-rp_F7zoafFDuR8CPUoKI,1271
 rclone_api/mount.py,sha256=TE_VIBMW7J1UkF_6HRCt8oi_jGdMov4S51bm2OgxFAM,10045
 rclone_api/mount_read_chunker.py,sha256=bi4N-VkyPdM4RWUYhIqJ71lQrXanck4PpF3pY8k2xnQ,4722
-rclone_api/process.py,sha256=xmI4T9i1tQfAy9lfwVU3w8sndkDkbM5KVUNWiKHCemY,5226
-rclone_api/rclone.py,sha256=gL0b41BBedj23EmNJtZHpFI0_NGHbz2WT0PIq4KLZKg,50215
+rclone_api/process.py,sha256=BGXJTZVT__jeaDyjN8_kRycliOhkBErMPdHO1hKRvJE,5271
+rclone_api/rclone.py,sha256=359ARr5FutcEzzO7vSAwnCvWzdLcN_nR6PW_Eov1BO8,52096
 rclone_api/remote.py,sha256=O9WDUFQy9f6oT1HdUbTixK2eg0xtBBm8k4Xl6aa6K00,431
 rclone_api/rpath.py,sha256=8ZA_1wxWtskwcy0I8V2VbjKDmzPkiWd8Q2JQSvh-sYE,2586
 rclone_api/scan_missing_folders.py,sha256=Kulca2Q6WZodt00ATFHkmqqInuoPvBkhTcS9703y6po,4740
@@ -23,8 +24,13 @@ rclone_api/types.py,sha256=XiiWoGXAzNxTEfRcszw3BeRF7ZATXHIAPFg2-aJzUfo,9926
 rclone_api/util.py,sha256=F9Q3zbWRsgPF4NG6OWB63cZ7GVq82lsraP47gmmDohU,5416
 rclone_api/walk.py,sha256=-54NVE8EJcCstwDoaC_UtHm73R2HrZwVwQmsnv55xNU,3369
 rclone_api/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
+rclone_api/cmd/analyze.py,sha256=RHbvk1G5ZUc3qLqlm1AZEyQzd_W_ZjcbCNDvW4YpTKQ,1252
 rclone_api/cmd/copy_large_s3.py,sha256=nOpAUAQN1mJnf4EIZCh4OVCW7Q4_EXJeLFVe6r_9rZA,3369
+rclone_api/cmd/fill_db.py,sha256=vCnfbwkPdxeR-c8khyUtAJZs6LmRrlfW0x8_ZqiDKj8,1548
 rclone_api/cmd/list_files.py,sha256=x8FHODEilwKqwdiU1jdkeJbLwOqUkUQuDWPo2u_zpf0,741
+rclone_api/db/__init__.py,sha256=OSRUdnSWUlDTOHmjdjVmxYTUNpTbtaJ5Ll9sl-PfZg0,40
+rclone_api/db/db.py,sha256=j39iDI6kiI3X0TwQwWkLeo3fnTVNlwuc6pdg6L7Nnq0,9932
+rclone_api/db/models.py,sha256=unKEiu8l4R4UAEoncEbOHEda227DpXm-cWwRV6vwJXE,1657
 rclone_api/experimental/flags.py,sha256=qCVD--fSTmzlk9hloRLr0q9elzAOFzPsvVpKM3aB1Mk,2739
 rclone_api/experimental/flags_base.py,sha256=ajU_czkTcAxXYU-SlmiCfHY7aCQGHvpCLqJ-Z8uZLk0,2102
 rclone_api/profile/mount_copy_bytes.py,sha256=nZtqMukLhSzHq64Pn1I8pXwjoraqWjCKey3WLAeubx0,9069
@@ -35,9 +41,9 @@ rclone_api/s3/chunk_types.py,sha256=oSWv8No9V3BeM7IcGnowyR2a7YrszdAXzEJlxaeZcp0,
 rclone_api/s3/create.py,sha256=wgfkapv_j904CfKuWyiBIWJVxfAx_ftemFSUV14aT68,3149
 rclone_api/s3/types.py,sha256=Elmh__gvZJyJyElYwMmvYZIBIunDJiTRAbEg21GmsRU,1604
 rclone_api/s3/upload_file_multipart.py,sha256=d8ZWqO8n9wsqRF6JjmvAFmG1aCkFqdSB1L8yxe_5qiY,11669
-rclone_api-1.3.7.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-rclone_api-1.3.7.dist-info/METADATA,sha256=OfqlMlZKb0YGl8hN6ae_Y1Icx2RKqlYj4UsMmcrAlEY,4536
-rclone_api-1.3.7.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
-rclone_api-1.3.7.dist-info/entry_points.txt,sha256=TV8kwP3FRzYwUEr0RLC7aJh0W03SAefIJNXTJ-FdMIQ,200
-rclone_api-1.3.7.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
-rclone_api-1.3.7.dist-info/RECORD,,
+rclone_api-1.3.8.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+rclone_api-1.3.8.dist-info/METADATA,sha256=TrFUV6iwuk5auxFRQFShVRQXhSYIaAZhv3a2MMF82Zs,4609
+rclone_api-1.3.8.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
+rclone_api-1.3.8.dist-info/entry_points.txt,sha256=TV8kwP3FRzYwUEr0RLC7aJh0W03SAefIJNXTJ-FdMIQ,200
+rclone_api-1.3.8.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
+rclone_api-1.3.8.dist-info/RECORD,,