rclone-api 1.3.18__py2.py3-none-any.whl → 1.3.19__py2.py3-none-any.whl

rclone_api/db/db.py

@@ -1,277 +1,277 @@
-"""
-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
-
-        # When running multiple commands in parallel, the database connection may fail once
-        # when the database is first populated.
-        retries = 2
-        for _ in range(retries):
-            try:
-                self.engine = create_engine(db_path_url)
-                SQLModel.metadata.create_all(self.engine)
-                break
-            except Exception as e:
-                print(f"Failed to connect to database. Retrying... {e}")
-        else:
-            raise Exception("Failed to connect to database.")
-        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.real_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.real_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
+"""
+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
+
+        # When running multiple commands in parallel, the database connection may fail once
+        # when the database is first populated.
+        retries = 2
+        for _ in range(retries):
+            try:
+                self.engine = create_engine(db_path_url)
+                SQLModel.metadata.create_all(self.engine)
+                break
+            except Exception as e:
+                print(f"Failed to connect to database. Retrying... {e}")
+        else:
+            raise Exception("Failed to connect to database.")
+        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.real_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.real_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

@@ -1,57 +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
+"""
+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

@@ -71,6 +71,7 @@ class FileItem:
     mime_type: str
     mod_time: str
     hash: str | None = None
+    id: int | None = None
 
     @property
     def path(self) -> str:

rclone_api/mount_read_chunker.py

@@ -115,8 +115,9 @@ class MultiMountFileChunker:
                 self._release_mount(mount)
 
                 if isinstance(bytes_or_err, Exception):
+                    err: Exception = bytes_or_err
                     logger.warning(f"Fetch task returned exception: {bytes_or_err}")
-                    return FilePart(payload=bytes_or_err, extra=extra)
+                    return FilePart(payload=err, extra=extra)
                 logger.debug(f"Successfully fetched {size} bytes from offset {offset}")
                 out = FilePart(payload=bytes_or_err, extra=extra)
                 return out

rclone_api/s3/chunk_task.py

@@ -115,7 +115,9 @@ class _OnCompleteHandler:
 
         # done_part_numbers.add(part_number)
         # queue_upload.put(fp)
-        self.part_number_tracker.add_finished_part_number(part_number)
+        self.part_number_tracker.add_finished_part_number(
+            part_number
+        )  # in memory database, not persistant to resume.json
         self.queue_upload.put(fp)
 
 

rclone_api/s3/upload_file_multipart.py

@@ -61,25 +61,29 @@ def handle_upload(
     upload_info: UploadInfo, fp: FilePart | EndOfStream
 ) -> FinishedPiece | Exception | EndOfStream:
     if isinstance(fp, EndOfStream):
-        return fp
-    assert isinstance(fp.extra, S3FileInfo)
-    extra: S3FileInfo = fp.extra
-    part_number = extra.part_number
-    print(f"Handling upload for {part_number}, size {fp.size}")
+        eos: EndOfStream = fp
+        return eos
+    part_number: int | None = None
     try:
+        assert isinstance(fp.extra, S3FileInfo)
+        extra: S3FileInfo = fp.extra
+        part_number = extra.part_number
+        print(f"Handling upload for {part_number}, size {fp.size}")
+
         part: FinishedPiece = upload_task(
             info=upload_info,
             chunk=fp.load(),
             part_number=part_number,
             retries=upload_info.retries,
         )
-        fp.close()
         return part
     except Exception as e:
         stacktrace = traceback.format_exc()
         msg = f"Error uploading part {part_number}: {e}\n{stacktrace}"
         warnings.warn(msg)
         return e
+    finally:
+        fp.close()
 
 
 def prepare_upload_file_multipart(

rclone_api/types.py

@@ -1,3 +1,4 @@
+import atexit
 import os
 import re
 import time
@@ -267,6 +268,26 @@ class EndOfStream:
     pass
 
 
+_CLEANUP_LIST: list[Path] = []
+
+
+def _add_for_cleanup(path: Path) -> None:
+    _CLEANUP_LIST.append(path)
+
+
+def _on_exit_cleanup() -> None:
+    paths = list(_CLEANUP_LIST)
+    for path in paths:
+        try:
+            if path.exists():
+                path.unlink()
+        except Exception as e:
+            warnings.warn(f"Cannot cleanup {path}: {e}")
+
+
+atexit.register(_on_exit_cleanup)
+
+
 class FilePart:
     def __init__(self, payload: bytes | Exception, extra: Any) -> None:
         from rclone_api.util import random_str
@@ -280,8 +301,9 @@ class FilePart:
         self.payload = get_chunk_tmpdir() / f"{random_str(12)}.chunk"
         with _TMP_DIR_ACCESS_LOCK:
             if not self.payload.parent.exists():
-                self.payload.parent.mkdir(parents=True)
+                self.payload.parent.mkdir(parents=True, exist_ok=True)
             self.payload.write_bytes(payload)
+        _add_for_cleanup(self.payload)
 
     @property
     def size(self) -> int:

{rclone_api-1.3.18.dist-info → rclone_api-1.3.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.3.18
+Version: 1.3.19
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 License: BSD 3-Clause License

{rclone_api-1.3.18.dist-info → rclone_api-1.3.19.dist-info}/RECORD

@@ -8,19 +8,19 @@ 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=aBHzC-sqwPJ5fSI8bj9XOXJY_I6aCevnxXqiLscl4oo,5393
+rclone_api/file.py,sha256=cz-7_nJArkVdJ9z2QaC_XZYpihXe3IPBC90Z5_3g2aw,5419
 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/mount_read_chunker.py,sha256=7jaF1Rsjr-kXIZW--Ol1QuG7WArBgdIcpQ0AJMYn7bI,4764
 rclone_api/process.py,sha256=BGXJTZVT__jeaDyjN8_kRycliOhkBErMPdHO1hKRvJE,5271
 rclone_api/rclone.py,sha256=ogWjSt--Ph2dpeq31mWsBRBvKhpf1EF0jJD2HxgQ8T0,50903
 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
-rclone_api/types.py,sha256=XiiWoGXAzNxTEfRcszw3BeRF7ZATXHIAPFg2-aJzUfo,9926
+rclone_api/types.py,sha256=OYO14H6Xf6u2nHbrzfoMbGbU7LRPhALaRA9FEClf8OI,10388
 rclone_api/util.py,sha256=F9Q3zbWRsgPF4NG6OWB63cZ7GVq82lsraP47gmmDohU,5416
 rclone_api/walk.py,sha256=-54NVE8EJcCstwDoaC_UtHm73R2HrZwVwQmsnv55xNU,3369
 rclone_api/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
@@ -29,21 +29,21 @@ rclone_api/cmd/copy_large_s3.py,sha256=nOpAUAQN1mJnf4EIZCh4OVCW7Q4_EXJeLFVe6r_9r
 rclone_api/cmd/list_files.py,sha256=x8FHODEilwKqwdiU1jdkeJbLwOqUkUQuDWPo2u_zpf0,741
 rclone_api/cmd/save_to_db.py,sha256=ylvnhg_yzexM-m6Zr7XDiswvoDVSl56ELuFAdb9gqBY,1957
 rclone_api/db/__init__.py,sha256=OSRUdnSWUlDTOHmjdjVmxYTUNpTbtaJ5Ll9sl-PfZg0,40
-rclone_api/db/db.py,sha256=1yoom28TGwCKVkb9WFbgDTTYE4SxmYfALDEUTW8_Pms,10351
-rclone_api/db/models.py,sha256=unKEiu8l4R4UAEoncEbOHEda227DpXm-cWwRV6vwJXE,1657
+rclone_api/db/db.py,sha256=ZpYfeCUe8MKg_fdJucRSe6-fwGY_rWqUn7WkHCNFH_4,10074
+rclone_api/db/models.py,sha256=v7qaXUehvsDvU51uk69JI23fSIs9JFGcOa-Tv1c_wVs,1600
 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
 rclone_api/s3/api.py,sha256=PafsIEyWDpLWAXsZAjFm9CY14vJpsDr9lOsn0kGRLZ0,4009
 rclone_api/s3/basic_ops.py,sha256=hK3366xhVEzEcjz9Gk_8lFx6MRceAk72cax6mUrr6ko,2104
-rclone_api/s3/chunk_task.py,sha256=plrQyjuHFdJfV55kKH4wqo6QGll9n4_7BO4B1A7j6kY,7121
+rclone_api/s3/chunk_task.py,sha256=kA6_5fLNdtT3QdTFrfBY6y8sH9Og8nM2mrjgAz_g1Rc,7196
 rclone_api/s3/chunk_types.py,sha256=oSWv8No9V3BeM7IcGnowyR2a7YrszdAXzEJlxaeZcp0,8852
 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.18.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-rclone_api-1.3.18.dist-info/METADATA,sha256=ow95lJm4jG8h05LuHtbeagZgL8R_qb7dqtwYU9s0cV4,4598
-rclone_api-1.3.18.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
-rclone_api-1.3.18.dist-info/entry_points.txt,sha256=fJteOlYVwgX3UbNuL9jJ0zUTuX2O79JFAeNgK7Sw7EQ,255
-rclone_api-1.3.18.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
-rclone_api-1.3.18.dist-info/RECORD,,
+rclone_api/s3/upload_file_multipart.py,sha256=eVjaRoE0xfoOFmiYRuwz3tVfT2TvJl2lSYSAut12fMg,11765
+rclone_api-1.3.19.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+rclone_api-1.3.19.dist-info/METADATA,sha256=fN9Od_VwYlO6TkvAdThtH-GdpyFUlkhXTpOGU0n-Dpk,4598
+rclone_api-1.3.19.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
+rclone_api-1.3.19.dist-info/entry_points.txt,sha256=fJteOlYVwgX3UbNuL9jJ0zUTuX2O79JFAeNgK7Sw7EQ,255
+rclone_api-1.3.19.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
+rclone_api-1.3.19.dist-info/RECORD,,