b10-transfer 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

b10_transfer/__init__.py

@@ -9,7 +9,7 @@ from .constants import OperationStatus
 from .logging_utils import get_b10_logger
 
 # Version
-__version__ = "0.3.1"
+__version__ = "0.3.3"
 
 __all__ = [
     "CacheError",

b10_transfer/archive.py

@@ -1,10 +1,9 @@
 import os
-import logging
 import subprocess
 from pathlib import Path
 
 from .utils import timed_fn, safe_unlink, CacheValidationError, validate_path_security
-from .constants import MAX_CACHE_SIZE_MB
+from .config import config
 from .logging_utils import get_b10_logger
 
 logger = get_b10_logger(__name__)
@@ -62,7 +61,7 @@ def _compress_directory_to_tar(source_dir: Path, target_file: Path) -> None:
 
 @timed_fn(logger=logger, name="Creating archive")
 def create_archive(
-    source_dir: Path, target_file: Path, max_size_mb: int = MAX_CACHE_SIZE_MB
+    source_dir: Path, target_file: Path, max_size_mb: int = config.MAX_CACHE_SIZE_MB
 ) -> None:
     """Create a compressed archive with path validation and size limits.
 
@@ -75,7 +74,7 @@ def create_archive(
                    allowed directories (/tmp/ or its parent).
         target_file: Path where the archive will be created. Must be within
                     allowed directories (/app or /cache).
-        max_size_mb: Maximum allowed archive size in megabytes. Defaults to MAX_CACHE_SIZE_MB.
+        max_size_mb: Maximum allowed archive size in megabytes. Defaults to config.MAX_CACHE_SIZE_MB.
 
     Raises:
         CacheValidationError: If paths are outside allowed directories.

b10_transfer/cache.py

@@ -26,12 +26,8 @@ from .space_monitor import (
     run_monitored_process,
     worker_process,
 )
+from .config import config
 from .constants import (
-    TORCH_CACHE_DIR,
-    B10FS_CACHE_DIR,
-    LOCAL_WORK_DIR,
-    MAX_CACHE_SIZE_MB,
-    REQUIRED_B10FS_SPACE_MB,
     MIN_LOCAL_SPACE_MB,
     CACHE_FILE_EXTENSION,
     CACHE_LATEST_SUFFIX,
@@ -64,9 +60,9 @@ def _setup_cache_paths():
     # Cooperative cleanup of stale shared resources
     cooperative_cleanup_b10fs()
 
-    b10fs_dir = Path(B10FS_CACHE_DIR)
-    torch_dir = Path(TORCH_CACHE_DIR)
-    work_dir = Path(LOCAL_WORK_DIR)
+    b10fs_dir = Path(config.B10FS_CACHE_DIR)
+    torch_dir = Path(config.TORCH_CACHE_DIR)
+    work_dir = Path(config.LOCAL_WORK_DIR)
 
     return b10fs_dir, torch_dir, work_dir
 
@@ -305,14 +301,14 @@ def save_compile_cache() -> OperationStatus:
             with temp_file_cleanup(local_temp):
                 # Phase 1: Compression with space monitoring
                 logger.info(
-                    f"[SAVING] Phase 1: Compressing torch cache directory ({torch_dir} -> {local_temp}, max size: {MAX_CACHE_SIZE_MB} MB)"
+                    f"[SAVING] Phase 1: Compressing torch cache directory ({torch_dir} -> {local_temp}, max size: {config.MAX_CACHE_SIZE_MB} MB)"
                 )
                 _run_with_space_monitoring(
-                    REQUIRED_B10FS_SPACE_MB,
+                    config.REQUIRED_B10FS_SPACE_MB,
                     b10fs_dir,
                     "compression",
                     _cache_compression_worker,
-                    (str(torch_dir), str(local_temp), MAX_CACHE_SIZE_MB),
+                    (str(torch_dir), str(local_temp), config.MAX_CACHE_SIZE_MB),
                 )
 
                 # Phase 2: Copy to b10fs with locking
@@ -357,7 +353,7 @@ def clear_local_cache() -> bool:
     Raises:
         Exception: Any errors during directory removal (caught and returns False).
     """
-    torch_dir = Path(TORCH_CACHE_DIR)
+    torch_dir = Path(config.TORCH_CACHE_DIR)
     if not torch_dir.exists():
         logger.info(
             f"[CLEARING] No torch cache directory found at {torch_dir}, nothing to clear"

b10_transfer/cache_cli.py

@@ -8,6 +8,7 @@ import urllib.request
 from dataclasses import dataclass
 
 from .cache import load_compile_cache, save_compile_cache
+from .config import config
 from .constants import OperationStatus
 
 
@@ -76,6 +77,9 @@ def _wait_for_ready(cfg: WaitCfg, logger: logging.Logger) -> bool:
 
 
 def main() -> None:
+    vllm_cache_dir = os.getenv("VLLM_CACHE_ROOT", "~/.cache/vllm")
+    os.environ["TORCHINDUCTOR_CACHE"] = vllm_cache_dir
+
     cfg = WaitCfg(
         url=DEFAULT_URL,
         timeout_s=DEFAULT_TIMEOUT_S,

b10_transfer/cleanup.py

@@ -7,12 +7,11 @@ lock files and incomplete cache files.
 
 import fnmatch
 import time
-import logging
 from pathlib import Path
-from typing import List, Tuple
+from typing import List
 
+from .config import config
 from .constants import (
-    B10FS_CACHE_DIR,
     CACHE_INCOMPLETE_SUFFIX,
     CLEANUP_LOCK_TIMEOUT_SECONDS,
     CLEANUP_INCOMPLETE_TIMEOUT_SECONDS,
@@ -119,7 +118,7 @@ def cooperative_cleanup_b10fs() -> None:
     This function is safe to run concurrently from multiple pods as file
     deletion operations are atomic and missing files are handled gracefully.
     """
-    b10fs_dir = Path(B10FS_CACHE_DIR)
+    b10fs_dir = Path(config.B10FS_CACHE_DIR)
     if not b10fs_dir.exists():
         logger.debug("[CLEANUP] b10fs cache directory doesn't exist, skipping cleanup")
         return
@@ -153,26 +152,26 @@ def get_cleanup_info() -> dict:
         dict: Dictionary containing cleanup configuration and statistics:
             - lock_timeout_seconds: Current lock file cleanup threshold
             - incomplete_timeout_seconds: Current incomplete file cleanup threshold
-            - b10fs_cache_dir: Path to b10fs cache directory
+            - b10_cache_dir: Path to b10fs cache directory
             - b10fs_exists: Whether b10fs cache directory exists
             - stale_locks_count: Number of lock files that would be cleaned
             - stale_incomplete_count: Number of incomplete files that would be cleaned
     """
-    b10fs_dir = Path(B10FS_CACHE_DIR)
+    b10fs_dir = Path(config.B10FS_CACHE_DIR)
 
     info = {
-        "lock_timeout_seconds": CLEANUP_LOCK_TIMEOUT_SECONDS,
-        "incomplete_timeout_seconds": CLEANUP_INCOMPLETE_TIMEOUT_SECONDS,
+        "lock_timeout_seconds": config.CLEANUP_LOCK_TIMEOUT_SECONDS,
+        "incomplete_timeout_seconds": config.CLEANUP_INCOMPLETE_TIMEOUT_SECONDS,
         "b10fs_cache_dir": str(b10fs_dir),
         "b10fs_exists": b10fs_dir.exists(),
         "stale_locks_count": len(
-            _find_stale_files(b10fs_dir, "*.lock", CLEANUP_LOCK_TIMEOUT_SECONDS)
+            _find_stale_files(b10fs_dir, "*.lock", config.CLEANUP_LOCK_TIMEOUT_SECONDS)
         ),
         "stale_incomplete_count": len(
             _find_stale_files(
                 b10fs_dir,
                 f"*{CACHE_INCOMPLETE_SUFFIX}*",
-                CLEANUP_INCOMPLETE_TIMEOUT_SECONDS,
+                config.CLEANUP_INCOMPLETE_TIMEOUT_SECONDS,
             )
         ),
     }

b10_transfer/config.py

@@ -0,0 +1,158 @@
+import os
+from typing import List
+
+from .utils import (
+    get_current_username,
+    validate_path_security,
+    validate_boolean_env,
+    apply_cap,
+)
+from .constants import (
+    MAX_CACHE_SIZE_CAP_MB,
+    MAX_CONCURRENT_SAVES_CAP,
+    MIN_LOCAL_SPACE_MB,
+    LOCK_TIMEOUT_CAP_SECONDS,
+    INCOMPLETE_TIMEOUT_CAP_SECONDS,
+    REQUIRED_TORCH_CACHE_DIR_PREFIX,
+)
+
+
+class Config:
+    def _allowed_torch_cache_prefixes(self) -> List[str]:
+        home_cache = os.path.expanduser("~/.cache")
+        return ["/tmp/", "/cache/", f"{home_cache}"]
+
+    # --------- dynamic properties ---------
+    @property
+    def TORCH_CACHE_DIR(self) -> str:
+        """
+        Validated torch compile cache directory.
+
+        Env:
+          - TORCHINDUCTOR_CACHE_DIR (optional)
+            Defaults to /tmp/torchinductor_<username> if not set.
+        """
+        default_dir = f"/tmp/torchinductor_{get_current_username()}"
+        chosen = os.getenv("TORCHINDUCTOR_CACHE_DIR", default_dir)
+        return validate_path_security(
+            chosen,
+            self._allowed_torch_cache_prefixes(),
+            "TORCHINDUCTOR_CACHE_DIR",
+        )
+
+    @property
+    def B10FS_CACHE_DIR(self) -> str:
+        """
+        Validated B10FS cache directory.
+
+        Env:
+          - B10FS_CACHE_DIR (optional)
+            Defaults to f"{REQUIRED_TORCH_CACHE_DIR_PREFIX}/compile_cache"
+        """
+        default_dir = f"{REQUIRED_TORCH_CACHE_DIR_PREFIX}/compile_cache"
+        chosen = os.getenv("B10FS_CACHE_DIR", default_dir)
+        return validate_path_security(
+            chosen,
+            [REQUIRED_TORCH_CACHE_DIR_PREFIX],
+            "B10FS_CACHE_DIR",
+        )
+
+    @property
+    def LOCAL_WORK_DIR(self) -> str:
+        """
+        Validated local work directory.
+
+        Env:
+          - LOCAL_WORK_DIR (optional, default: /app)
+        """
+        chosen = os.getenv("LOCAL_WORK_DIR", "/app")
+        return validate_path_security(
+            chosen,
+            ["/app/", "/tmp/", "/cache/"],
+            "LOCAL_WORK_DIR",
+        )
+
+    @property
+    def MAX_CACHE_SIZE_MB(self) -> int:
+        """
+        Max size of a single cache archive (MB), capped for safety.
+
+        Env:
+          - MAX_CACHE_SIZE_MB (optional, default: 1024)
+        Caps:
+          - <= MAX_CACHE_SIZE_CAP_MB
+        """
+        requested = int(os.getenv("MAX_CACHE_SIZE_MB", 1024))
+        return apply_cap(requested, MAX_CACHE_SIZE_CAP_MB, "MAX_CACHE_SIZE_MB")
+
+    @property
+    def MAX_CONCURRENT_SAVES(self) -> int:
+        """
+        Max concurrent save operations, capped for safety.
+
+        Env:
+          - MAX_CONCURRENT_SAVES (optional, default: 50)
+        Caps:
+          - <= MAX_CONCURRENT_SAVES_CAP
+        """
+        requested = int(os.getenv("MAX_CONCURRENT_SAVES", 50))
+        return apply_cap(requested, MAX_CONCURRENT_SAVES_CAP, "MAX_CONCURRENT_SAVES")
+
+    @property
+    def REQUIRED_B10FS_SPACE_MB(self) -> int:
+        """
+        Estimated required space on B10FS (MB) based on concurrency and per-archive size.
+        Lower-bounded to ensure a sane minimum.
+        """
+        return max(self.MAX_CONCURRENT_SAVES * self.MAX_CACHE_SIZE_MB, 100_000)
+
+    @property
+    def MIN_LOCAL_SPACE_MB(self) -> int:
+        """Minimum required free space on local filesystem (MB)."""
+        return MIN_LOCAL_SPACE_MB
+
+    @property
+    def BASETEN_FS_ENABLED(self) -> bool:
+        """
+        Whether Baseten FS features are enabled.
+
+        Env:
+          - BASETEN_FS_ENABLED (string "0" or "1", default "0")
+        """
+        raw = os.getenv("BASETEN_FS_ENABLED", "0")
+        return validate_boolean_env(raw, "BASETEN_FS_ENABLED")
+
+    @property
+    def CLEANUP_LOCK_TIMEOUT_SECONDS(self) -> int:
+        """
+        Timeout for cleaning up lock files (seconds).
+
+        Env:
+          - CLEANUP_LOCK_TIMEOUT_SECONDS (optional, default: 30)
+        Caps:
+          - <= LOCK_TIMEOUT_CAP_SECONDS
+        """
+        requested = int(os.getenv("CLEANUP_LOCK_TIMEOUT_SECONDS", 30))
+        return apply_cap(
+            requested, LOCK_TIMEOUT_CAP_SECONDS, "CLEANUP_LOCK_TIMEOUT_SECONDS"
+        )
+
+    @property
+    def CLEANUP_INCOMPLETE_TIMEOUT_SECONDS(self) -> int:
+        """
+        Timeout for cleaning up incomplete files (seconds).
+
+        Env:
+          - CLEANUP_INCOMPLETE_TIMEOUT_SECONDS (optional, default: 60)
+        Caps:
+          - <= INCOMPLETE_TIMEOUT_CAP_SECONDS
+        """
+        requested = int(os.getenv("CLEANUP_INCOMPLETE_TIMEOUT_SECONDS", 60))
+        return apply_cap(
+            requested,
+            INCOMPLETE_TIMEOUT_CAP_SECONDS,
+            "CLEANUP_INCOMPLETE_TIMEOUT_SECONDS",
+        )
+
+
+config = Config()

b10_transfer/constants.py

@@ -1,113 +1,30 @@
-"""Configuration constants for b10-transfer.
-
-This module defines configuration constants for the PyTorch compilation cache system.
-Some values can be overridden by environment variables, but security caps are enforced
-to prevent malicious or accidental misuse in production environments.
-"""
-
-import os
 from enum import Enum, auto
 
-# Import helper functions from utils to avoid duplication
-from .utils import (
-    get_current_username,
-    validate_path_security,
-    validate_boolean_env,
-    apply_cap,
-)
-
-# Cache directories with security validation
-
-# Validate TORCH_CACHE_DIR - allow /tmp and /cache paths
-# TORCHINDUCTOR_CACHE_DIR is what torch uses by default. If it is not set, we use a different value.
-_torch_cache_dir = os.getenv(
-    "TORCHINDUCTOR_CACHE_DIR", f"/tmp/torchinductor_{get_current_username()}"
-)
-TORCH_CACHE_DIR = validate_path_security(
-    _torch_cache_dir,
-    ["/tmp/", "/cache/", f"{os.path.expanduser('~')}/.cache"],
-    "TORCHINDUCTOR_CACHE_DIR",
-)
-
-# B10FS cache directory validation
-_REQUIRED_TORCH_CACHE_DIR_PREFIX = "/cache/model"
-_b10fs_cache_dir = os.getenv(
-    "B10FS_CACHE_DIR", f"{_REQUIRED_TORCH_CACHE_DIR_PREFIX}/compile_cache"
-)
-B10FS_CACHE_DIR = validate_path_security(
-    _b10fs_cache_dir, [_REQUIRED_TORCH_CACHE_DIR_PREFIX], "B10FS_CACHE_DIR"
-)
-
-# Validate LOCAL_WORK_DIR - allow /app, /tmp, and /cache paths
-_local_work_dir = os.getenv("LOCAL_WORK_DIR", "/app")
-LOCAL_WORK_DIR = validate_path_security(
-    _local_work_dir, ["/app/", "/tmp/", "/cache/"], "LOCAL_WORK_DIR"
-)
-
-# Security caps to prevent resource exhaustion
-_MAX_CACHE_SIZE_CAP_MB = 1 * 1024  # 1GB hard limit per cache archive
-_MAX_CONCURRENT_SAVES_CAP = 100  # Maximum concurrent save operations (only used as estimate for b10fs space requirements/thresholding)
+# ----- Hard caps & fixed thresholds (security / safety) -----
+MAX_CACHE_SIZE_CAP_MB: int = 1 * 1024  # 1GB hard limit per cache archive
+MAX_CONCURRENT_SAVES_CAP: int = 100  # Max concurrent save ops (estimate for space calc)
 
+# Minimum required space on local disk
+MIN_LOCAL_SPACE_MB: int = 50 * 1024  # 50GB
 
-# Cache limits (capped for security)
-_user_max_cache_size = int(os.getenv("MAX_CACHE_SIZE_MB", "1024"))
-MAX_CACHE_SIZE_MB = apply_cap(
-    _user_max_cache_size, _MAX_CACHE_SIZE_CAP_MB, "MAX_CACHE_SIZE_MB"
-)
+# Cleanup hard limits
+LOCK_TIMEOUT_CAP_SECONDS: int = 3600  # 1 hour hard limit
+INCOMPLETE_TIMEOUT_CAP_SECONDS: int = 7200  # 2 hours hard limit
 
-_user_max_concurrent_saves = int(os.getenv("MAX_CONCURRENT_SAVES", "50"))
-MAX_CONCURRENT_SAVES = apply_cap(
-    _user_max_concurrent_saves, _MAX_CONCURRENT_SAVES_CAP, "MAX_CONCURRENT_SAVES"
-)
-
-# Space requirements
-MIN_LOCAL_SPACE_MB = 50 * 1024  # 50GB minimum space on local machine
-REQUIRED_B10FS_SPACE_MB = max(MAX_CONCURRENT_SAVES * MAX_CACHE_SIZE_MB, 100_000)
-
-# B10FS configuration
-# The default is "0" (disabled) to prevent accidental enabling.
-# But this does limit the ability to enable b10fs for debugging purposes.
-# Probably should use B10FS_ENABLED instead for that.
-_baseten_fs_enabled = os.getenv("BASETEN_FS_ENABLED", "0")
-BASETEN_FS_ENABLED = validate_boolean_env(_baseten_fs_enabled, "BASETEN_FS_ENABLED")
+# Allowed / required path patterns
+REQUIRED_TORCH_CACHE_DIR_PREFIX: str = "/cache/model"  # For B10FS cache dir validation
 
 # File naming patterns
-CACHE_FILE_EXTENSION = ".tar.gz"
-CACHE_LATEST_SUFFIX = ".latest"
-CACHE_INCOMPLETE_SUFFIX = ".incomplete"
-CACHE_PREFIX = "cache_"
-
-
-# Space monitoring settings
-SPACE_MONITOR_CHECK_INTERVAL_SECONDS = (
-    0.5  # How often to check disk space during operations
-)
-
-# Cooperative cleanup settings
-# Cache operations (load/save) should complete within ~15 seconds under normal conditions
-_LOCK_TIMEOUT_CAP_SECONDS = 3600  # 1 hour hard limit
-_INCOMPLETE_TIMEOUT_CAP_SECONDS = 7200  # 2 hours hard limit
-
-# Lock file cleanup timeout (default: 2x expected operation time)
-_user_lock_timeout = int(
-    os.getenv("CLEANUP_LOCK_TIMEOUT_SECONDS", "30")
-)  # 30 seconds default
-CLEANUP_LOCK_TIMEOUT_SECONDS = apply_cap(
-    _user_lock_timeout, _LOCK_TIMEOUT_CAP_SECONDS, "CLEANUP_LOCK_TIMEOUT_SECONDS"
-)
+CACHE_FILE_EXTENSION: str = ".tar.gz"
+CACHE_LATEST_SUFFIX: str = ".latest"
+CACHE_INCOMPLETE_SUFFIX: str = ".incomplete"
+CACHE_PREFIX: str = "cache_"
 
-# Incomplete file cleanup timeout (default: 3x expected operation time)
-_user_incomplete_timeout = int(
-    os.getenv("CLEANUP_INCOMPLETE_TIMEOUT_SECONDS", "60")
-)  # 1 minute default
-CLEANUP_INCOMPLETE_TIMEOUT_SECONDS = apply_cap(
-    _user_incomplete_timeout,
-    _INCOMPLETE_TIMEOUT_CAP_SECONDS,
-    "CLEANUP_INCOMPLETE_TIMEOUT_SECONDS",
-)
+# Monitoring cadence
+SPACE_MONITOR_CHECK_INTERVAL_SECONDS: float = 0.5
 
 
-# Worker process result status enum
+# ----- Enums -----
 class WorkerStatus(Enum):
     """Status values for worker process results."""
 
@@ -122,4 +39,4 @@ class OperationStatus(Enum):
     SUCCESS = auto()
     ERROR = auto()
     DOES_NOT_EXIST = auto()  # Used by load operations when cache file not found
-    SKIPPED = auto()  # Used by load/save operations when operation not needed
+    SKIPPED = auto()  # Used by load/save ops when operation not needed

b10_transfer/core.py

@@ -20,9 +20,8 @@ from .space_monitor import (
     run_monitored_process,
     worker_process,
 )
+from .config import config
 from .constants import (
-    B10FS_CACHE_DIR,
-    REQUIRED_B10FS_SPACE_MB,
     MIN_LOCAL_SPACE_MB,
     OperationStatus,
 )
@@ -68,9 +67,9 @@ def transfer(source: str, dest: str) -> OperationStatus:
 
     # Determine appropriate space threshold based on destination directory
     dest_dir = dest_path.parent
-    if str(dest_dir).startswith(B10FS_CACHE_DIR):
+    if str(dest_dir).startswith(config.B10FS_CACHE_DIR):
         # Transferring to b10fs - use b10fs space requirements
-        space_threshold_mb = REQUIRED_B10FS_SPACE_MB
+        space_threshold_mb = config.REQUIRED_B10FS_SPACE_MB
         logger.debug(
             f"[TRANSFER] Transfer to b10fs detected, using {space_threshold_mb:.1f}MB threshold"
         )

b10_transfer/environment.py

@@ -6,8 +6,6 @@ GPU hardware and driver information for cache compatibility.
 
 import hashlib
 import json
-import logging
-import os
 
 # Optional imports - may not be available in all environments
 try:

b10_transfer/info.py

@@ -4,9 +4,8 @@ from typing import Dict, Any
 
 from .environment import get_cache_filename, get_environment_key
 from .archive import get_file_size_mb
+from .config import config
 from .constants import (
-    TORCH_CACHE_DIR,
-    B10FS_CACHE_DIR,
     CACHE_PREFIX,
     CACHE_LATEST_SUFFIX,
     CACHE_FILE_EXTENSION,
@@ -91,8 +90,8 @@ def get_cache_info() -> Dict[str, Any]:
     Raises:
         No exceptions are raised; errors are handled gracefully with None values.
     """
-    torch_dir = Path(TORCH_CACHE_DIR)
-    b10fs_dir = Path(B10FS_CACHE_DIR)
+    torch_dir = Path(config.TORCH_CACHE_DIR)
+    b10fs_dir = Path(config.B10FS_CACHE_DIR)
     cache_filename = get_cache_filename()
     cache_file = (
         b10fs_dir / f"{cache_filename}{CACHE_LATEST_SUFFIX}{CACHE_FILE_EXTENSION}"
@@ -143,7 +142,7 @@ def list_available_caches() -> Dict[str, Any]:
             "error": "b10fs is not enabled",
         }
 
-    b10fs_dir = Path(B10FS_CACHE_DIR)
+    b10fs_dir = Path(config.B10FS_CACHE_DIR)
 
     if not b10fs_dir.exists():
         return {

b10_transfer/logging_utils.py

@@ -1,7 +1,6 @@
 """Centralized logging utilities for b10-transfer package with colored output."""
 
 import logging
-from typing import Optional
 
 
 class ColoredFormatter(logging.Formatter):

b10_transfer/space_monitor.py

@@ -5,7 +5,6 @@ from exhausting available disk space and causing system instability.
 """
 
 import time
-import logging
 import shutil
 import threading
 import multiprocessing

b10_transfer/utils.py

@@ -1,6 +1,4 @@
-import os
 import time
-import logging
 import getpass
 from pathlib import Path
 from contextlib import contextmanager

{b10_transfer-0.3.1.dist-info → b10_transfer-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: b10-transfer
-Version: 0.3.1
+Version: 0.3.3
 Summary: Distributed PyTorch file transfer for Baseten - Environment-aware, lock-free file transfer management
 License: MIT
 Keywords: pytorch,file-transfer,cache,machine-learning,inference

b10_transfer-0.3.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+b10_transfer/__init__.py,sha256=L8OwbhGYoj1iqlNgSCwUZP_RWOswduqdOeSyeku4cQQ,729
+b10_transfer/archive.py,sha256=RGk7pmOdF24aATKygkFOAfHB-90arnW67nj-WURZfcw,6424
+b10_transfer/cache.py,sha256=VbAQx935rqdMXu6ejloa6Jw3n2KxkSMp3VLrNrgP--k,17480
+b10_transfer/cache_cli.py,sha256=29H7HPKOvHP2LVI6J1Gad42iTXAZIwVqjvrZyIuCb_Q,3378
+b10_transfer/cleanup.py,sha256=_i8WPwtnqiSD2CSLJfGOttE7SMJd_TUTnIqz4wI4pRE,6369
+b10_transfer/config.py,sha256=z_7emRsb-IG7_KbGy9jLtzkbIkLGEbKpWDUPWC_PB58,4661
+b10_transfer/constants.py,sha256=oBfAvw2QyCRS1rFD9g1kDaToQqRX2bcnCVBUnCYD8uQ,1323
+b10_transfer/core.py,sha256=r79CI8Kpw9FyT17qYOze4tg4UyoL_EQXiucX5YiqXEM,4659
+b10_transfer/environment.py,sha256=7DcEFmuxEMWwRM0M92q8al5rx8mpGY8dZ81Hokhb9B0,5577
+b10_transfer/info.py,sha256=MR6gXvL3gBImnafuDgbOsZAHy9_akwZVlyIPGu2t8jQ,6345
+b10_transfer/logging_utils.py,sha256=c7iKNK9daNsrkHgsKl32rXscqqmWsq3a8ttz9M5ev3o,3460
+b10_transfer/space_monitor.py,sha256=24rClldo6EYaeikEla3_q4IwwI0r3DEPzaIbfU4hTRE,10746
+b10_transfer/utils.py,sha256=eyCckvl11xFOdsac4pjLEAleoahhIlBqAr81mwoGO-o,12036
+b10_transfer-0.3.3.dist-info/METADATA,sha256=L3J79MxdrmgZ4dHo2H63jtPC9m8v9WRGhDXdIBAz__U,4108
+b10_transfer-0.3.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+b10_transfer-0.3.3.dist-info/entry_points.txt,sha256=AFH8EfkeBv6ZuarnaUvbTjvySylf3GCSioYqB_ijrH8,65
+b10_transfer-0.3.3.dist-info/RECORD,,

b10_transfer-0.3.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-b10_transfer/__init__.py,sha256=90KV_leqq1fVtM3oZAZh4v8vdIcnhATmxlqlrqRMel8,729
-b10_transfer/archive.py,sha256=gunAZ6oTUz0SxodUCho1uP-MNLuQyuhMKFusx7E0xDg,6439
-b10_transfer/cache.py,sha256=k759Cs4IIUdAJ90ctK1m8ws3Fceje8ckug09L8X6W5I,17518
-b10_transfer/cache_cli.py,sha256=aTM59jNNpEQ0m95YLYn9d1yjSTXZkzYAMszGqrDGmt4,3228
-b10_transfer/cleanup.py,sha256=IAjRlpzCcXVrokTXdOsm_EJo_-U5kiy8KJoip8V4vvk,6345
-b10_transfer/constants.py,sha256=0RWa4ZusICpYoN_V0u4yj4GZfcouQ6PjfCvSRVUamJU,4368
-b10_transfer/core.py,sha256=Ny4lViiPup4Zb_OCx_Z2IcbcWq42Ymj_zF7xyVroHxE,4668
-b10_transfer/environment.py,sha256=NkIs3EevhfATMZS0KL7f1w3SSoxAF9rCrA9qYkhbV7s,5602
-b10_transfer/info.py,sha256=WlpSQNEKi93d3EYo2HnbbzrLazOhK9dpX5w7Kf6DVfA,6339
-b10_transfer/logging_utils.py,sha256=vnjnuVsVO5bibHSHiF5sYhHqfprIezU0fM3YaCugMC0,3488
-b10_transfer/space_monitor.py,sha256=-hFc9f29K-7gF1vDZRrKDa-FrHkmD6OBLsV8l8knrMM,10761
-b10_transfer/utils.py,sha256=XG4dGLAlQQyUPeIK48OzuDkz1SOpdEs2_GrXKd8fr5M,12061
-b10_transfer-0.3.1.dist-info/METADATA,sha256=jFlRoRUeru5LfMwkn5lvxIbumYBpooncVHbeUzvxBXc,4108
-b10_transfer-0.3.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-b10_transfer-0.3.1.dist-info/entry_points.txt,sha256=AFH8EfkeBv6ZuarnaUvbTjvySylf3GCSioYqB_ijrH8,65
-b10_transfer-0.3.1.dist-info/RECORD,,