unifiedefficientloader 0.2.0__py3-none-any.whl

unifiedefficientloader/__init__.py

@@ -0,0 +1,36 @@
+import importlib.util
+
+def check_dependencies(*packages):
+    """
+    Check if required packages are installed.
+    Throws a descriptive error if not.
+    """
+    missing = []
+    for pkg in packages:
+        if importlib.util.find_spec(pkg) is None:
+            missing.append(pkg)
+    
+    if missing:
+        missing_str = ", ".join(missing)
+        raise ImportError(
+            f"Missing required packages for unifiedefficientloader: {missing_str}. "
+            f"Please install them using: pip install {missing_str}"
+        )
+
+# Pre-check torch as it is the foundation of most of these tools
+check_dependencies("torch")
+
+from .memory_efficient_loader import UnifiedSafetensorsLoader, MemoryEfficientSafeOpen
+from .tensor_utils import dict_to_tensor, tensor_to_dict
+from .pinned_transfer import transfer_to_gpu_pinned, set_verbose, get_pinned_transfer_stats, reset_pinned_transfer_stats
+
+__all__ = [
+    "UnifiedSafetensorsLoader",
+    "MemoryEfficientSafeOpen",
+    "dict_to_tensor",
+    "tensor_to_dict",
+    "transfer_to_gpu_pinned",
+    "set_verbose",
+    "get_pinned_transfer_stats",
+    "reset_pinned_transfer_stats",
+]

unifiedefficientloader/memory_efficient_loader.py

@@ -0,0 +1,361 @@
+"""
+Unified safetensors loader with optional memory-efficient mode.
+
+Provides a consistent interface for tensor loading regardless of mode.
+Requires `torch`, `safetensors`, and optionally `tqdm`.
+"""
+import gc
+import json
+import struct
+import logging
+from typing import Dict, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+def _ensure_torch():
+    try:
+        import torch
+        return torch
+    except ImportError:
+        raise ImportError("The 'torch' package is required but not installed. Please install it.")
+
+def _ensure_safetensors():
+    try:
+        import safetensors
+        from safetensors import safe_open
+        return safe_open
+    except ImportError:
+        raise ImportError("The 'safetensors' package is required but not installed. Please install it.")
+
+try:
+    import torch
+except ImportError:
+    pass
+
+class UnifiedSafetensorsLoader:
+    """Unified safetensors loader supporting both preload and streaming modes.
+
+    In standard mode (low_memory=False):
+        - Loads all tensors upfront (fast, uses more RAM)
+        - Tensors remain in memory until explicitly deleted
+
+    In low-memory mode (low_memory=True):
+        - Loads tensors on-demand via get_tensor()
+        - Caller should delete tensors after processing
+
+    Usage:
+        with UnifiedSafetensorsLoader("model.safetensors", low_memory=True) as loader:
+            for key in loader.keys():
+                tensor = loader.get_tensor(key)
+                # ... process tensor ...
+                loader.mark_processed(key)  # Frees memory in low_memory mode
+    """
+
+    def __init__(self, filename: str, low_memory: bool = False):
+        """Initialize the loader.
+
+        Args:
+            filename: Path to safetensors file
+            low_memory: If True, use streaming mode; if False, preload all tensors
+        """
+        torch = _ensure_torch()
+        safe_open = _ensure_safetensors()
+        
+        self.filename = filename
+        self.low_memory = low_memory
+        self._tensors: Dict[str, 'torch.Tensor'] = {}
+        self._all_keys = []
+        self._file = None
+        self._header = None
+        self._header_size = None
+        self._metadata: Dict[str, str] = {}
+
+        if low_memory:
+            # Streaming mode: read header only
+            self._header, self._header_size = self._read_header()
+            self._file = None # Opened lazily to support multiprocessing DataLoader
+            self._all_keys = [k for k in self._header.keys() if k != "__metadata__"]
+            # Extract metadata from header (safetensors stores it under __metadata__ key)
+            self._metadata = self._header.get("__metadata__", {})
+            logger.debug(f"Initialized Low-memory mode: parsed header of size {self._header_size} bytes.")
+            logger.debug(f"Found {len(self._all_keys)} tensors (streaming mode)")
+        else:
+            # Standard mode: preload all tensors
+            with safe_open(filename, framework="pt", device="cpu") as f:
+                self._metadata = f.metadata() or {}
+                self._all_keys = list(f.keys())
+                print(f"Loading {len(self._all_keys)} tensors from source file...")
+                try:
+                    from tqdm import tqdm
+                    iterator = tqdm(self._all_keys, desc="Loading tensors")
+                except ImportError:
+                    iterator = self._all_keys
+                
+                for key in iterator:
+                    self._tensors[key] = f.get_tensor(key)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def __getstate__(self):
+        """Make loader picklable for multiprocessing DataLoaders."""
+        state = self.__dict__.copy()
+        state['_file'] = None
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+
+    def close(self):
+        """Close file handle and release resources."""
+        if self._file:
+            self._file.close()
+            self._file = None
+        self._tensors.clear()
+
+    def keys(self):
+        """Return list of all tensor keys."""
+        return self._all_keys
+
+    def metadata(self) -> Dict[str, str]:
+        """Return file metadata."""
+        return self._metadata
+
+    def get_shape(self, key: str) -> tuple:
+        """Get tensor shape without loading tensor data.
+
+        In low-memory mode, reads from header.
+        In standard mode, returns shape from loaded tensor.
+        """
+        if self.low_memory:
+            if key not in self._header:
+                raise KeyError(f"Tensor '{key}' not found in file")
+            return tuple(self._header[key]["shape"])
+        else:
+            return tuple(self._tensors[key].shape)
+
+    def get_ndim(self, key: str) -> int:
+        """Get tensor ndim without loading tensor data."""
+        return len(self.get_shape(key))
+
+    def get_tensor(self, key: str) -> 'torch.Tensor':
+        """Get a tensor by key.
+
+        In standard mode, returns from cache.
+        In low-memory mode, loads from file on-demand.
+        """
+        if not self.low_memory:
+            # Standard mode: return from preloaded cache
+            return self._tensors[key]
+
+        # Low-memory mode: load on-demand
+        if key not in self._header:
+            raise KeyError(f"Tensor '{key}' not found in file")
+
+        if self._file is None:
+            self._file = open(self.filename, "rb")
+
+        metadata = self._header[key]
+        offset_start, offset_end = metadata["data_offsets"]
+
+        if offset_start != offset_end:
+            logger.debug(f"Loading tensor '{key}' from offset {offset_start} to {offset_end} ({(offset_end - offset_start)} bytes)")
+            self._file.seek(self._header_size + 8 + offset_start)
+            # Use bytearray to create a writable buffer, avoiding PyTorch warning
+            # about non-writable tensors from read-only bytes.
+            tensor_bytes = bytearray(offset_end - offset_start)
+            self._file.readinto(tensor_bytes)
+        else:
+            tensor_bytes = None
+
+        return self._deserialize_tensor(tensor_bytes, metadata)
+
+    def mark_processed(self, key: str):
+        """Mark a tensor as processed, freeing memory if in low-memory mode.
+
+        In standard mode, optionally deletes from cache.
+        In low-memory mode, this is a no-op (tensor was never cached).
+        """
+        if not self.low_memory and key in self._tensors:
+            del self._tensors[key]
+            gc.collect()
+
+    def _read_header(self):
+        """Read and parse the safetensors header."""
+        with open(self.filename, "rb") as f:
+            header_size = struct.unpack("<Q", f.read(8))[0]
+            header_json = f.read(header_size).decode("utf-8")
+        return json.loads(header_json), header_size
+
+    def _deserialize_tensor(self, tensor_bytes, metadata):
+        """Deserialize raw bytes into a torch tensor."""
+        torch = _ensure_torch()
+        dtype_str = metadata["dtype"]
+        shape = metadata["shape"]
+        dtype = self._get_torch_dtype(dtype_str)
+
+        if tensor_bytes is None:
+            byte_tensor = torch.empty(0, dtype=torch.uint8)
+        else:
+            byte_tensor = torch.frombuffer(tensor_bytes, dtype=torch.uint8)
+
+        if dtype_str in ["F8_E5M2", "F8_E4M3"]:
+            return self._convert_float8(byte_tensor, dtype_str, shape)
+
+        return byte_tensor.view(dtype).reshape(shape)
+
+    @staticmethod
+    def _get_torch_dtype(dtype_str: str):
+        """Map safetensors dtype string to torch dtype."""
+        torch = _ensure_torch()
+        dtype_map = {
+            "F64": torch.float64,
+            "F32": torch.float32,
+            "F16": torch.float16,
+            "BF16": torch.bfloat16,
+            "I64": torch.int64,
+            "I32": torch.int32,
+            "I16": torch.int16,
+            "I8": torch.int8,
+            "U8": torch.uint8,
+            "BOOL": torch.bool,
+        }
+        if hasattr(torch, "float8_e5m2"):
+            dtype_map["F8_E5M2"] = torch.float8_e5m2
+        if hasattr(torch, "float8_e4m3fn"):
+            dtype_map["F8_E4M3"] = torch.float8_e4m3fn
+
+        dtype = dtype_map.get(dtype_str)
+        if dtype is None:
+            raise ValueError(f"Unsupported dtype: {dtype_str}")
+        return dtype
+
+    @staticmethod
+    def _convert_float8(byte_tensor, dtype_str: str, shape: list):
+        """Convert bytes to float8 tensor."""
+        torch = _ensure_torch()
+        if dtype_str == "F8_E5M2" and hasattr(torch, "float8_e5m2"):
+            return byte_tensor.view(torch.float8_e5m2).reshape(shape)
+        elif dtype_str == "F8_E4M3" and hasattr(torch, "float8_e4m3fn"):
+            return byte_tensor.view(torch.float8_e4m3fn).reshape(shape)
+        else:
+            raise ValueError(f"Unsupported float8 type: {dtype_str}")
+
+    def async_stream(self, keys: list, batch_size: int = 1, prefetch_batches: int = 2, pin_memory: bool = False):
+        """Asynchronously stream tensors from disk.
+        
+        Args:
+            keys: List of tensor keys to load
+            batch_size: Number of tensors to yield in each batch
+            prefetch_batches: Number of batches to pre-fetch in background
+            pin_memory: If True, tensors will be pinned in CPU memory (sequentially in main thread)
+            
+        Yields:
+            List of (key, tensor) tuples
+        """
+        import threading
+        import queue
+        from concurrent.futures import ThreadPoolExecutor
+
+        torch = _ensure_torch()
+        thread_local = threading.local()
+
+        def get_file_handle():
+            if not hasattr(thread_local, 'file'):
+                thread_local.file = open(self.filename, "rb")
+            return thread_local.file
+
+        def _worker_load(key):
+            try:
+                # Direct thread-safe read
+                metadata = self._header[key]
+                offset_start, offset_end = metadata["data_offsets"]
+                if offset_start != offset_end:
+                    f = get_file_handle()
+                    f.seek(self._header_size + 8 + offset_start)
+                    tensor_bytes = bytearray(offset_end - offset_start)
+                    f.readinto(tensor_bytes)
+                else:
+                    tensor_bytes = None
+
+                tensor = self._deserialize_tensor(tensor_bytes, metadata)
+                return key, tensor, None
+            except Exception as e:
+                # Fallback info for main thread
+                return key, None, e
+
+        # Queue for individual (key, tensor) pairs
+        # Size it to hold enough for prefetch_batches
+        q = queue.Queue(maxsize=prefetch_batches * batch_size)
+        
+        def _producer():
+            # Use a reasonable number of workers for I/O bound tasks
+            max_workers = min(16, max(4, batch_size))
+            # Limit task submission to maintain backpressure on memory
+            max_in_flight = max(max_workers, prefetch_batches * batch_size)
+            
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                futures = []
+                key_iter = iter(keys)
+                
+                # Fill the pipeline
+                for _ in range(max_in_flight):
+                    try:
+                        k = next(key_iter)
+                        futures.append(executor.submit(_worker_load, k))
+                    except StopIteration:
+                        break
+                
+                while futures:
+                    # Maintain order by taking the first future
+                    f = futures.pop(0)
+                    result = f.result() # Blocks until this specific tensor is loaded
+                    q.put(result)       # Blocks if the consumption queue is full
+                    
+                    # Submit next task if available
+                    try:
+                        k = next(key_iter)
+                        futures.append(executor.submit(_worker_load, k))
+                    except StopIteration:
+                        pass
+                        
+            q.put(None) # Sentinel
+
+        producer_thread = threading.Thread(target=_producer, daemon=True)
+        producer_thread.start()
+
+        batch = []
+        while True:
+            res = q.get()
+            if res is None:
+                if batch:
+                    yield batch
+                break
+            
+            k, t, err = res
+            if err is not None:
+                logger.warning(f"Async load failed for {k}, falling back to sync: {err}")
+                # Fallback synchronous load
+                try:
+                    t = self.get_tensor(k)
+                except Exception as sync_err:
+                    logger.error(f"Sync fallback also failed for {k}: {sync_err}")
+                    raise sync_err
+            
+            # Pin memory sequentially in the main thread to avoid OS-level lock contention
+            if pin_memory and t.device.type == 'cpu':
+                try:
+                    t = t.pin_memory()
+                except Exception as e:
+                    logger.warning(f"Failed to pin memory for {k}: {e}")
+            
+            batch.append((k, t))
+            if len(batch) == batch_size:
+                yield batch
+                batch = []
+
+# Backward compatibility alias
+MemoryEfficientSafeOpen = UnifiedSafetensorsLoader

unifiedefficientloader/pinned_transfer.py

@@ -0,0 +1,89 @@
+"""
+Pinned memory utilities for faster CPU→GPU tensor transfers.
+
+Pinned (page-locked) memory enables faster DMA transfers to GPU.
+Uses PyTorch's native pin_memory() with non_blocking transfers.
+"""
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+def _ensure_torch():
+    try:
+        import torch
+        return torch
+    except ImportError:
+        raise ImportError("The 'torch' package is required but not installed. Please install it.")
+
+# Module-level configuration
+_verbose = False
+_pinned_transfer_stats = {"pinned": 0, "fallback": 0}
+
+def set_verbose(enabled: bool):
+    """Enable/disable verbose output for pinned transfers."""
+    global _verbose
+    _verbose = enabled
+
+def get_pinned_transfer_stats():
+    """Return pinned transfer statistics for verification."""
+    return _pinned_transfer_stats.copy()
+
+def reset_pinned_transfer_stats():
+    """Reset transfer statistics."""
+    global _pinned_transfer_stats
+    _pinned_transfer_stats = {"pinned": 0, "fallback": 0}
+
+def transfer_to_gpu_pinned(
+    tensor,
+    device: str = 'cuda',
+    dtype = None
+):
+    """Transfer tensor to GPU using pinned memory for faster transfer."""
+    torch = _ensure_torch()
+    global _pinned_transfer_stats
+
+    # Skip if not a CPU tensor or CUDA unavailable
+    if tensor.device.type != 'cpu' or not torch.cuda.is_available():
+        if dtype is not None:
+            return tensor.to(device=device, dtype=dtype)
+        return tensor.to(device=device)
+
+    # Skip if target is not CUDA
+    if not str(device).startswith('cuda'):
+        if dtype is not None:
+            return tensor.to(device=device, dtype=dtype)
+        return tensor.to(device=device)
+
+    try:
+        pinned = tensor.pin_memory()
+
+        if dtype is not None:
+            result = pinned.to(device=device, dtype=dtype, non_blocking=True)
+        else:
+            result = pinned.to(device=device, non_blocking=True)
+
+        torch.cuda.current_stream().synchronize()
+
+        # One-time confirmation on first success
+        if _pinned_transfer_stats["pinned"] == 0:
+            logger.debug("[pinned_transfer] Pinned memory active - faster GPU transfers enabled")
+
+        _pinned_transfer_stats["pinned"] += 1
+        if _verbose:
+            logger.debug(f"[pinned_transfer] Pinned: {tensor.shape} ({tensor.numel() * tensor.element_size() / 1024:.1f} KB)")
+        else:
+            logger.debug(f"[pinned_transfer] Transferred tensor {tensor.shape} to {device} via pinned memory")
+
+        return result
+
+    except Exception as e:
+        _pinned_transfer_stats["fallback"] += 1
+        if _verbose:
+            logger.debug(f"[pinned_transfer] Fallback: {e}")
+        else:
+            logger.debug(f"[pinned_transfer] Fallback transfer to {device} due to error: {e}")
+
+        if dtype is not None:
+            return tensor.to(device=device, dtype=dtype)
+        return tensor.to(device=device)

unifiedefficientloader/tensor_utils.py

@@ -0,0 +1,54 @@
+"""
+Tensor utility functions.
+
+Provides serialization helpers for dictionary/tensor conversion.
+Requires `torch`.
+"""
+import json
+import logging
+from typing import Dict, Tuple
+
+logger = logging.getLogger(__name__)
+
+def _ensure_torch():
+    try:
+        import torch
+        return torch
+    except ImportError:
+        raise ImportError("The 'torch' package is required but not installed. Please install it.")
+
+
+def dict_to_tensor(data_dict: dict):
+    """
+    Convert a dictionary to a torch.uint8 tensor containing JSON bytes.
+
+    Args:
+        data_dict: Dictionary to serialize
+
+    Returns:
+        torch.uint8 tensor containing UTF-8 encoded JSON
+    """
+    torch = _ensure_torch()
+    json_str = json.dumps(data_dict)
+    byte_data = json_str.encode("utf-8")
+    tensor_data = torch.tensor(list(byte_data), dtype=torch.uint8)
+    logger.debug(f"dict_to_tensor: serialized dict to uint8 tensor of shape {tensor_data.shape}")
+    return tensor_data
+
+def tensor_to_dict(tensor_data) -> dict:
+    """
+    Convert a torch.uint8 tensor containing JSON bytes to a dictionary.
+
+    Args:
+        tensor_data: Tensor containing UTF-8 encoded JSON bytes
+
+    Returns:
+        Parsed dictionary
+    """
+    if tensor_data.ndim != 1:
+        raise ValueError(f"Expected a 1D tensor for dict conversion, got {tensor_data.ndim}D tensor.")
+    byte_data = bytes(tensor_data.tolist())
+    json_str = byte_data.decode("utf-8")
+    data_dict = json.loads(json_str)
+    logger.debug(f"tensor_to_dict: deserialized tensor of shape {tensor_data.shape} to dict with keys: {list(data_dict.keys())}")
+    return data_dict

unifiedefficientloader-0.2.0.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: unifiedefficientloader
+Version: 0.2.0
+Summary: A unified interface for memory efficient per tensor loading of safetensors files as raw bytes from offset, handling CPU/GPU pinned transfers, and converting between tensors and dicts.
+Author: silveroxides
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: torch
+Requires-Dist: torch; extra == "torch"
+Provides-Extra: safetensors
+Requires-Dist: safetensors; extra == "safetensors"
+Provides-Extra: tqdm
+Requires-Dist: tqdm; extra == "tqdm"
+Provides-Extra: all
+Requires-Dist: torch; extra == "all"
+Requires-Dist: safetensors; extra == "all"
+Requires-Dist: tqdm; extra == "all"
+Dynamic: license-file
+
+# unifiedefficientloader
+
+A unified interface for loading safetensors, handling CPU/GPU pinned transfers, and converting between tensors and dicts.
+
+## Installation
+
+You can install this package via pip. Since it heavily relies on `torch` and `safetensors` but doesn't strictly force them as hard dependencies for package building/installation, make sure you have them installed in your environment:
+
+```bash
+pip install unifiedefficientloader
+pip install torch safetensors tqdm
+```
+
+## Usage
+
+### Unified Safetensors Loader
+
+```python
+from unifiedefficientloader import UnifiedSafetensorsLoader
+
+# Standard mode (preload all)
+with UnifiedSafetensorsLoader("model.safetensors", low_memory=False) as loader:
+    tensor = loader.get_tensor("weight_name")
+
+# Low memory mode (streaming)
+with UnifiedSafetensorsLoader("model.safetensors", low_memory=True) as loader:
+    for key in loader.keys():
+        tensor = loader.get_tensor(key)
+        # Process tensor...
+        loader.mark_processed(key) # Frees memory
+```
+
+### Loading Specific Tensors Dynamically (Header Analysis)
+
+You can analyze the file's header without loading the entire multi-gigabyte safetensors file into memory. This allows you to locate specific data (like embedded JSON dictionaries stored as `uint8` tensors) and load *only* those specific tensors directly from their file offsets.
+
+```python
+from unifiedefficientloader import UnifiedSafetensorsLoader, tensor_to_dict
+
+with UnifiedSafetensorsLoader("model.safetensors", low_memory=True) as loader:
+    # 1. Analyze the header metadata without loading any tensors
+    # loader._header contains the full safetensors header directory
+    uint8_tensor_keys = [
+        key for key, info in loader._header.items()
+        if isinstance(info, dict) and info.get("dtype") == "U8"
+    ]
+    
+    # 2. Load ONLY those specific tensors using their keys
+    for key in uint8_tensor_keys:
+        # get_tensor dynamically reads only the bytes for this tensor 
+        # based on the offsets found in the header
+        loaded_tensor = loader.get_tensor(key)
+        
+        # 3. Decode the uint8 tensor back into a Python dictionary
+        extracted_dict = tensor_to_dict(loaded_tensor)
+        print(f"Decoded {key}:", extracted_dict)
+```
+
+### Optimized Asynchronous Streaming via ThreadPoolExecutor
+
+For maximum I/O throughput while maintaining strict memory backpressure, use `async_stream`. This utilizes a `ThreadPoolExecutor` for background disk reading and a bounded queue to prevent memory exhaustion. By setting `pin_memory=True`, memory pinning is performed sequentially in the main thread to avoid OS-level lock contention and preserve high DMA transfer speeds.
+
+```python
+from unifiedefficientloader import UnifiedSafetensorsLoader, transfer_to_gpu_pinned
+
+with UnifiedSafetensorsLoader("model.safetensors", low_memory=True) as loader:
+    keys_to_load = loader.keys()
+    
+    # Create the continuous streaming generator
+    # prefetch_batches controls how many batches to buffer in memory
+    stream = loader.async_stream(
+        keys_to_load, 
+        batch_size=8, 
+        prefetch_batches=2, 
+        pin_memory=True
+    )
+    
+    # Iterate directly over the generator
+    for batch in stream:
+        for key, pinned_tensor in batch:
+            # Transfer directly to GPU via DMA (pinning is already done)
+            gpu_tensor = transfer_to_gpu_pinned(pinned_tensor, device="cuda")
+            
+            # ... process gpu_tensor ...
+            loader.mark_processed(key)
+```
+
+### Tensor/Dict Conversion
+
+```python
+from unifiedefficientloader import dict_to_tensor, tensor_to_dict
+
+my_dict = {"param": 1.0, "name": "test"}
+tensor = dict_to_tensor(my_dict)
+recovered_dict = tensor_to_dict(tensor)
+```
+
+### Pinned Memory Transfers
+
+```python
+import torch
+from unifiedefficientloader import transfer_to_gpu_pinned
+
+tensor = torch.randn(100, 100)
+# Transfers using pinned memory if CUDA is available, otherwise falls back gracefully
+gpu_tensor = transfer_to_gpu_pinned(tensor, device="cuda:0")

unifiedefficientloader-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+unifiedefficientloader/__init__.py,sha256=1BJELlRKRDkK_GDhg75xSBqQn3CSmDuvlxcSYcG6Mjw,1133
+unifiedefficientloader/memory_efficient_loader.py,sha256=4HE_mmjmde_7Z5L8gCc99AX2pN9byMjEvlcKjVwooso,13408
+unifiedefficientloader/pinned_transfer.py,sha256=ppMxVc9BY1fSmBgC_PTIs0NlCRY2cHHo33ZIn2zfcLo,2915
+unifiedefficientloader/tensor_utils.py,sha256=KiHiCPY8x97xrG-G_JyK-MKZsIVCNh44Wu_2oVA6mzc,1606
+unifiedefficientloader-0.2.0.dist-info/licenses/LICENSE,sha256=A9N3lbMEmsGuLe9EjTiWkDUkWHrKRRh_xcdvS3eHN5g,1063
+unifiedefficientloader-0.2.0.dist-info/METADATA,sha256=L1le1VCz46O6zxt4Xn4OVtunEg6Dr330lDKTouGgLr4,4999
+unifiedefficientloader-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+unifiedefficientloader-0.2.0.dist-info/top_level.txt,sha256=6PqrT67C60EgKKXNbtP7o3TBEWxV2XrLxQloZnGyREA,23
+unifiedefficientloader-0.2.0.dist-info/RECORD,,

unifiedefficientloader-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

unifiedefficientloader-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Silver
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

unifiedefficientloader-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+unifiedefficientloader