rclone-api 1.2.14__tar.gz → 1.2.154__tar.gz

{rclone_api-1.2.14 → rclone_api-1.2.154}/PKG-INFO

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

{rclone_api-1.2.14 → rclone_api-1.2.154}/pyproject.toml

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

{rclone_api-1.2.14 → rclone_api-1.2.154}/src/rclone_api/__init__.py

@@ -1,38 +1,45 @@
-from .completed_process import CompletedProcess
-from .config import Config, Parsed, Section
-from .diff import DiffItem, DiffOption, DiffType
-from .dir import Dir
-from .dir_listing import DirListing
-from .file import File
-from .filelist import FileList
-from .process import Process
-from .rclone import Rclone, rclone_verbose
-from .remote import Remote
-from .rpath import RPath
-from .s3.types import MultiUploadResult
-from .types import ListingOption, Order, SizeResult, SizeSuffix
-
-__all__ = [
-    "Rclone",
-    "File",
-    "Config",
-    "Remote",
-    "Dir",
-    "RPath",
-    "DirListing",
-    "FileList",
-    "Process",
-    "DiffItem",
-    "DiffType",
-    "rclone_verbose",
-    "CompletedProcess",
-    "DiffOption",
-    "ListingOption",
-    "Order",
-    "ListingOption",
-    "SizeResult",
-    "Parsed",
-    "Section",
-    "MultiUploadResult",
-    "SizeSuffix",
-]
+# Import logging module to activate default configuration
+import rclone_api.logging  # noqa: F401
+
+from .completed_process import CompletedProcess
+from .config import Config, Parsed, Section
+from .diff import DiffItem, DiffOption, DiffType
+from .dir import Dir
+from .dir_listing import DirListing
+from .file import File
+from .filelist import FileList
+
+# Import the configure_logging function to make it available at package level
+from .logging import configure_logging
+from .process import Process
+from .rclone import Rclone, rclone_verbose
+from .remote import Remote
+from .rpath import RPath
+from .s3.types import MultiUploadResult
+from .types import ListingOption, Order, SizeResult, SizeSuffix
+
+__all__ = [
+    "Rclone",
+    "File",
+    "Config",
+    "Remote",
+    "Dir",
+    "RPath",
+    "DirListing",
+    "FileList",
+    "Process",
+    "DiffItem",
+    "DiffType",
+    "rclone_verbose",
+    "CompletedProcess",
+    "DiffOption",
+    "ListingOption",
+    "Order",
+    "ListingOption",
+    "SizeResult",
+    "Parsed",
+    "Section",
+    "MultiUploadResult",
+    "SizeSuffix",
+    "configure_logging",
+]

rclone_api-1.2.154/src/rclone_api/logging.py

@@ -0,0 +1,39 @@
+import logging
+import sys
+
+
+def setup_default_logging():
+    """Set up default logging configuration if none exists."""
+    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()

{rclone_api-1.2.14 → rclone_api-1.2.154}/src/rclone_api/s3/chunk_file.py

@@ -1,145 +1,146 @@
-import time
-import warnings
-from concurrent.futures import Future
-from dataclasses import dataclass
-from pathlib import Path
-from queue import Queue
-from threading import Event
-from typing import Any, Callable
-
-from rclone_api.mount_read_chunker import FilePart
-from rclone_api.s3.chunk_types import UploadState
-from rclone_api.types import EndOfStream
-from rclone_api.util import locked_print
-
-
-def _get_file_size(file_path: Path, timeout: int = 60) -> int:
-    sleep_time = timeout / 60 if timeout > 0 else 1
-    start = time.time()
-    while True:
-        expired = time.time() - start > timeout
-        try:
-            time.sleep(sleep_time)
-            if file_path.exists():
-                return file_path.stat().st_size
-        except FileNotFoundError as e:
-            if expired:
-                print(f"File not found: {file_path}, exception is {e}")
-                raise
-        if expired:
-            raise TimeoutError(f"File {file_path} not found after {timeout} seconds")
-
-
-@dataclass
-class S3FileInfo:
-    upload_id: str
-    part_number: int
-
-
-def file_chunker(
-    upload_state: UploadState,
-    fetcher: Callable[[int, int, Any], Future[FilePart]],
-    max_chunks: int | None,
-    cancel_signal: Event,
-    queue_upload: Queue[FilePart | EndOfStream],
-) -> None:
-    count = 0
-
-    def should_stop() -> bool:
-        nonlocal count
-
-        if max_chunks is None:
-            return False
-        if count >= max_chunks:
-            print(
-                f"Stopping file chunker after {count} chunks because it exceeded max_chunks {max_chunks}"
-            )
-            return True
-        count += 1
-        return False
-
-    upload_info = upload_state.upload_info
-    file_path = upload_info.src_file_path
-    chunk_size = upload_info.chunk_size
-    # src = Path(file_path)
-
-    try:
-        part_number = 1
-        done_part_numbers: set[int] = {
-            p.part_number for p in upload_state.parts if not isinstance(p, EndOfStream)
-        }
-        num_parts = upload_info.total_chunks()
-
-        def next_part_number() -> int | None:
-            nonlocal part_number
-            while part_number in done_part_numbers:
-                part_number += 1
-            if part_number > num_parts:
-                return None
-            return part_number
-
-        if cancel_signal.is_set():
-            print(
-                f"Cancel signal is set for file chunker while processing {file_path}, returning"
-            )
-            return
-
-        while not should_stop():
-            print("@@@@@@@@@@")
-            curr_part_number = next_part_number()
-            if curr_part_number is None:
-                locked_print(f"File {file_path} has completed chunking all parts")
-                break
-            assert curr_part_number is not None
-            offset = (curr_part_number - 1) * chunk_size
-            file_size = upload_info.file_size
-
-            assert offset < file_size, f"Offset {offset} is greater than file size"
-
-            # Open the file, seek, read the chunk, and close immediately.
-            # with open(file_path, "rb") as f:
-            #     f.seek(offset)
-            #     data = f.read(chunk_size)
-
-            # data = chunk_fetcher(offset, chunk_size).result()
-
-            assert curr_part_number is not None
-            cpn: int = curr_part_number
-
-            def on_complete(fut: Future[FilePart]) -> None:
-                print("ON COMPLETE")
-                fp: FilePart = fut.result()
-                if fp.is_error():
-                    warnings.warn(
-                        f"Error reading file: {fp}, skipping part {part_number}"
-                    )
-                    return
-
-                if fp.n_bytes() == 0:
-                    warnings.warn(f"Empty data for part {part_number} of {file_path}")
-                    raise ValueError(
-                        f"Empty data for part {part_number} of {file_path}"
-                    )
-
-                if isinstance(fp.payload, Exception):
-                    warnings.warn(f"Error reading file because of error: {fp.payload}")
-                    return
-
-                done_part_numbers.add(part_number)
-                queue_upload.put(fp)
-
-            offset = (curr_part_number - 1) * chunk_size
-            print(f"Reading chunk {curr_part_number} of {num_parts} for {file_path}")
-            fut = fetcher(offset, file_size, S3FileInfo(upload_info.upload_id, cpn))
-            fut.add_done_callback(on_complete)
-            # wait until the queue_upload queue can accept the next chunk
-            while queue_upload.full():
-                time.sleep(0.1)
-    except Exception as e:
-
-        warnings.warn(f"Error reading file: {e}")
-    finally:
-        print("#############################################################")
-        print(f"Finishing FILE CHUNKER for {file_path} and adding EndOfStream")
-        print("#############################################################")
-        queue_upload.put(EndOfStream())
+import logging
+import time
+from concurrent.futures import Future
+from dataclasses import dataclass
+from pathlib import Path
+from queue import Queue
+from threading import Event
+from typing import Any, Callable
+
+from rclone_api.mount_read_chunker import FilePart
+from rclone_api.s3.chunk_types import UploadState
+from rclone_api.types import EndOfStream
+
+logger = logging.getLogger(__name__)  # noqa
+
+
+def _get_file_size(file_path: Path, timeout: int = 60) -> int:
+    sleep_time = timeout / 60 if timeout > 0 else 1
+    start = time.time()
+    while True:
+        expired = time.time() - start > timeout
+        try:
+            time.sleep(sleep_time)
+            if file_path.exists():
+                return file_path.stat().st_size
+        except FileNotFoundError as e:
+            if expired:
+                print(f"File not found: {file_path}, exception is {e}")
+                raise
+        if expired:
+            raise TimeoutError(f"File {file_path} not found after {timeout} seconds")
+
+
+@dataclass
+class S3FileInfo:
+    upload_id: str
+    part_number: int
+
+
+def file_chunker(
+    upload_state: UploadState,
+    fetcher: Callable[[int, int, Any], Future[FilePart]],
+    max_chunks: int | None,
+    cancel_signal: Event,
+    queue_upload: Queue[FilePart | EndOfStream],
+) -> None:
+    count = 0
+
+    def should_stop() -> bool:
+        nonlocal count
+
+        if max_chunks is None:
+            return False
+        if count >= max_chunks:
+            logger.info(
+                f"Stopping file chunker after {count} chunks because it exceeded max_chunks {max_chunks}"
+            )
+            return True
+        count += 1
+        return False
+
+    upload_info = upload_state.upload_info
+    file_path = upload_info.src_file_path
+    chunk_size = upload_info.chunk_size
+    # src = Path(file_path)
+
+    try:
+        part_number = 1
+        done_part_numbers: set[int] = {
+            p.part_number for p in upload_state.parts if not isinstance(p, EndOfStream)
+        }
+        num_parts = upload_info.total_chunks()
+
+        def next_part_number() -> int | None:
+            nonlocal part_number
+            while part_number in done_part_numbers:
+                part_number += 1
+            if part_number > num_parts:
+                return None
+            return part_number
+
+        if cancel_signal.is_set():
+            logger.info(
+                f"Cancel signal is set for file chunker while processing {file_path}, returning"
+            )
+            return
+
+        while not should_stop():
+            logger.debug("Processing next chunk")
+            curr_part_number = next_part_number()
+            if curr_part_number is None:
+                logger.info(f"File {file_path} has completed chunking all parts")
+                break
+            assert curr_part_number is not None
+            offset = (curr_part_number - 1) * chunk_size
+            file_size = upload_info.file_size
+
+            assert offset < file_size, f"Offset {offset} is greater than file size"
+
+            # Open the file, seek, read the chunk, and close immediately.
+            # with open(file_path, "rb") as f:
+            #     f.seek(offset)
+            #     data = f.read(chunk_size)
+
+            # data = chunk_fetcher(offset, chunk_size).result()
+
+            assert curr_part_number is not None
+            cpn: int = curr_part_number
+
+            def on_complete(fut: Future[FilePart]) -> None:
+                logger.debug("Chunk read complete")
+                fp: FilePart = fut.result()
+                if fp.is_error():
+                    logger.warning(
+                        f"Error reading file: {fp}, skipping part {part_number}"
+                    )
+                    return
+
+                if fp.n_bytes() == 0:
+                    logger.warning(f"Empty data for part {part_number} of {file_path}")
+                    raise ValueError(
+                        f"Empty data for part {part_number} of {file_path}"
+                    )
+
+                if isinstance(fp.payload, Exception):
+                    logger.warning(f"Error reading file because of error: {fp.payload}")
+                    return
+
+                done_part_numbers.add(part_number)
+                queue_upload.put(fp)
+
+            offset = (curr_part_number - 1) * chunk_size
+            logger.info(
+                f"Reading chunk {curr_part_number} of {num_parts} for {file_path}"
+            )
+            fut = fetcher(offset, file_size, S3FileInfo(upload_info.upload_id, cpn))
+            fut.add_done_callback(on_complete)
+            # wait until the queue_upload queue can accept the next chunk
+            while queue_upload.full():
+                time.sleep(0.1)
+    except Exception as e:
+
+        logger.error(f"Error reading file: {e}", exc_info=True)
+    finally:
+        logger.info(f"Finishing FILE CHUNKER for {file_path} and adding EndOfStream")
+        queue_upload.put(EndOfStream())

{rclone_api-1.2.14 → rclone_api-1.2.154}/src/rclone_api.egg-info/PKG-INFO

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

{rclone_api-1.2.14 → rclone_api-1.2.154}/src/rclone_api.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ src/rclone_api/exec.py
 src/rclone_api/file.py
 src/rclone_api/filelist.py
 src/rclone_api/group_files.py
+src/rclone_api/logging.py
 src/rclone_api/mount.py
 src/rclone_api/mount_read_chunker.py
 src/rclone_api/process.py