mmgp 3.4.6__py3-none-any.whl → 3.4.8__py3-none-any.whl

mmgp/offload.py

@@ -1,4 +1,4 @@
-# ------------------ Memory Management 3.4.5 for the GPU Poor by DeepBeepMeep (mmgp)------------------
+# ------------------ Memory Management 3.4.8 for the GPU Poor by DeepBeepMeep (mmgp)------------------
 #
 # This module contains multiples optimisations so that models such as Flux (and derived), Mochi, CogView, HunyuanVideo, ...  can run smoothly on a 24 GB GPU limited card. 
 # This a replacement for the accelerate library that should in theory manage offloading, but doesn't work properly with models that are loaded / unloaded several
@@ -331,12 +331,35 @@ def _extract_tie_weights_from_sd(sd , sd_name, verboseLevel =1):
 
 def _pin_sd_to_memory(sd, sd_name, tied_weights = None, gig_tensor_size = BIG_TENSOR_MAX_SIZE, verboseLevel = 1):
     global max_pinnable_bytes, total_pinned_bytes
+
+
+    names_list = sd_name if isinstance(sd, list) else [sd_name]
+
     if max_pinnable_bytes > 0 and  total_pinned_bytes >= max_pinnable_bytes:
 
         if  verboseLevel>=1 :
-            print(f"Unable pin data of '{sd_name}' to reserved RAM as there is no reserved RAM left")
+            print(f"Unable pin data of '{','.join(names_list)}' to reserved RAM as there is no reserved RAM left")
         return
 
+    
+    if isinstance(sd, list):
+        new_sd = {}
+        for i, sub_sd,  in enumerate(sd):
+            for k, v in sub_sd.items():
+                new_sd[str(i) + "#" + k] =v
+        sd = new_sd
+        del new_sd
+        sub_sd = None
+
+    if isinstance(tied_weights, list):
+        new_tied_weights = {}
+        for i, sub_tied_weights,  in enumerate(tied_weights):
+            for k, v in sub_tied_weights.items():
+                new_tied_weights[str(i) + "#" + k] =v
+        sd = new_tied_weights
+        del new_tied_weights
+        sub_tied_weights = None
+
     current_big_tensor_size = 0
     big_tensor_no  = 0
     big_tensors_sizes = []
@@ -365,11 +388,14 @@ def _pin_sd_to_memory(sd, sd_name, tied_weights = None, gig_tensor_size = BIG_TE
     big_tensors = []
     last_big_tensor = 0
     total = 0  
+    incomplete_pinning = False
 
     try:
         dummy_pinned_tensor = torch.empty( RESERVED_RAM_MIN_AVAILABLE, dtype= torch.uint8, pin_memory=True, device="cpu")
     except:
         print("There isn't any Reserved RAM left, you may need to choose a profile with a higher number that requires less Reserved RAM or set OS env 'perc_reserved_mem_max' to a value less 0.3")
+        gc.collect()
+        torch.cuda.empty_cache()
         return
     
     for size in big_tensors_sizes:
@@ -377,6 +403,7 @@ def _pin_sd_to_memory(sd, sd_name, tied_weights = None, gig_tensor_size = BIG_TE
             current_big_tensor = torch.empty( size, dtype= torch.uint8, pin_memory=True, device="cpu")
             big_tensors.append(current_big_tensor)
         except:
+            incomplete_pinning = True
             print(f"Unable to pin more tensors for '{sd_name}' as the maximum reservable memory has been reached ({total/ONE_MB:.2f})")
             break
 
@@ -410,9 +437,21 @@ def _pin_sd_to_memory(sd, sd_name, tied_weights = None, gig_tensor_size = BIG_TE
     # global total_pinned_bytes
     # total_pinned_bytes += total
     gc.collect()
+    torch.cuda.empty_cache()
+
 
     if verboseLevel >=1:
-        print(f"'{sd_name}' was pinned entirely to reserved RAM: {last_big_tensor} large blocks spread across {total/ONE_MB:.2f} MB")
+        if incomplete_pinning :
+            if len(names_list) > 0:
+                print(f"'{','.join(names_list)}' were partially pinned to reserved RAM: {last_big_tensor} large blocks spread across {total/ONE_MB:.2f} MB")
+            else:
+                print(f"'{','.join(names_list)}' was partially pinned to reserved RAM: {last_big_tensor} large blocks spread across {total/ONE_MB:.2f} MB")
+        else:
+            if len(names_list) > 0:
+                print(f"'{','.join(names_list)}' were pinned entirely to reserved RAM: {last_big_tensor} large blocks spread across {total/ONE_MB:.2f} MB")
+            else:
+                print(f"'{','.join(names_list)}' was pinned entirely to reserved RAM: {last_big_tensor} large blocks spread across {total/ONE_MB:.2f} MB")
+
 
     return 
 
@@ -619,7 +658,7 @@ def _welcome():
     if welcome_displayed:
          return 
     welcome_displayed = True
-    print(f"{BOLD}{HEADER}************ Memory Management for the GPU Poor (mmgp 3.4.5) by DeepBeepMeep ************{ENDC}{UNBOLD}")
+    print(f"{BOLD}{HEADER}************ Memory Management for the GPU Poor (mmgp 3.4.8) by DeepBeepMeep ************{ENDC}{UNBOLD}")
 
 def change_dtype(model, new_dtype, exclude_buffers = False):
     for submodule_name, submodule in model.named_modules():  
@@ -961,6 +1000,8 @@ def load_loras_into_model(model, lora_path, lora_multi = None, activate_all_lora
     errors  = []
     adapters = {}
     adapter_no = 0
+    pinned_sd_list = []
+    pinned_names_list = []
     for i, path in enumerate(lora_path):
         adapter_name = str(adapter_no)
         error_msg = ""
@@ -1042,28 +1083,37 @@ def load_loras_into_model(model, lora_path, lora_multi = None, activate_all_lora
             invalid_keys = []
             unexpected_keys = []
             for k, v in state_dict.items():
-                pos = k.rfind(".lora_")
-                if pos <=0:
-                    invalid_keys.append(k)
-                    continue
-                module_name = k[ : pos]
-                lora_key = k[ pos+1:]
                 lora_A = None
                 lora_B = None
-                if lora_key == "lora_A.weight":
-                    lora_A = v
-                elif lora_key == "lora_B.weight":
-                    lora_B = v
+                diff_b = None
+                diff = None
+                if k.endswith(".diff"):
+                    diff = v
+                    module_name = k[ : -5]
+                elif k.endswith(".diff_b"):
+                    diff_b = v
+                    module_name = k[ : -7]
                 else:
-                    invalid_keys.append(k)
-                    continue
+                    pos = k.rfind(".lora_")
+                    if pos <=0:
+                        invalid_keys.append(k)
+                        continue
+                    module_name = k[ : pos]
+                    lora_key = k[ pos+1:]
+                    if lora_key in ("lora_A.weight", "lora_down.weight"):
+                        lora_A = v
+                    elif lora_key in ("lora_B.weight", "lora_up.weight"):
+                        lora_B = v
+                    else:
+                        invalid_keys.append(k)
+                        continue
 
                 module =  modules_dict.get(module_name, None)
                 if module == None:
                     unexpected_keys.append(k)
                     continue
-                if not isinstance(module, (QLinear, torch.nn.Linear)):
-                    msg = f"Lora '{path}' contains a non linear layer '{k}'"
+                if False: #not isinstance(module, (QLinear, torch.nn.Linear, torch.nn.Conv3d, torch.nn.LayerNorm)):
+                    msg = f"Lora '{path}' contains a non supported type of layer '{k}'"
                     error_msg = append(error_msg, msg) 
                     fail = True
                     break
@@ -1077,7 +1127,7 @@ def load_loras_into_model(model, lora_path, lora_multi = None, activate_all_lora
                             error_msg = append(error_msg, msg) 
                             fail = True
                         break
-                if lora_B != None:
+                elif lora_B != None:
                     if module_shape[0] != v.shape[0]:
                         if ignore_model_variations:
                             skip = True
@@ -1086,28 +1136,56 @@ def load_loras_into_model(model, lora_path, lora_multi = None, activate_all_lora
                             error_msg = append(error_msg, msg) 
                             fail = True
                         break
+                elif diff != None:
+                    lora_B = diff
+                    if module_shape != v.shape:
+                        if ignore_model_variations:
+                            skip = True
+                        else:
+                            msg = f"Lora '{path}': Lora shape is not compatible with model '{_get_module_name(model)}' (model = {module_shape[0]}, lora = {v.shape[0]}). It is likely this Lora has been made for another version of this model."
+                            error_msg = append(error_msg, msg) 
+                            fail = True
+                        break
+                elif diff_b != None:
+                    if module.bias == None:
+                        msg = f"Lora '{path}': Lora Basis is defined while it doesnt exist in model '{_get_module_name(model)}'. It is likely this Lora has been made for another version of this model."
+                        fail = True
+                        break
+                    else:
+                        module_shape = module.bias.shape
+                        if module_shape != v.shape:
+                            if ignore_model_variations:
+                                skip = True
+                            else:
+                                msg = f"Lora '{path}': Lora Basis dimension is not compatible with model '{_get_module_name(model)}' (model = {module_shape[0]}, lora Basis = {v.shape[0]}). It is likely this Lora has been made for another version of this model."
+                                error_msg = append(error_msg, msg) 
+                                fail = True
+                            break
+                
                 if not check_only:
                     loras_module_data = loras_model_data.get(module, None)
+                    if loras_module_data == None:
+                        pass
                     assert loras_module_data != None
-                    # if loras_module_data == None:
-                    #     loras_module_data = dict()
-                    #     loras_model_data[module] = loras_module_data
                     loras_adapter_data =  loras_module_data.get(adapter_name, None)
                     lora_A = None if lora_A == None else lora_A.to(module.weight.dtype) 
                     lora_B = None if lora_B == None else lora_B.to(module.weight.dtype) 
+                    diff_b = None if diff_b == None else diff_b.to(module.weight.dtype) 
                     if loras_adapter_data == None:
                         alpha = lora_alphas.get(k[:-len("lora_X.weight")] + "alpha", 1.) 
-                        loras_adapter_data = [lora_A, lora_B, alpha]
+                        loras_adapter_data = [lora_A, lora_B, diff_b, alpha]
                         loras_module_data[adapter_name] = loras_adapter_data
                     elif lora_A != None:
                         loras_adapter_data[0] = lora_A
-                    else:
+                    elif lora_B != None:
                         loras_adapter_data[1] = lora_B
-            lora_A, lora_B, v, loras_module_data, loras_adapter_data = None, None, None, None, None
+                    else:
+                        loras_adapter_data[2] = diff_b
+            lora_A, lora_B, diff, diff_b, v, loras_module_data, loras_adapter_data = None, None, None, None, None, None, None
             lora_alphas = None
 
             if len(invalid_keys)  > 0:
-                msg = "Lora '{path}' contains non Lora keys '{trunc(invalid_keys,200)}'"
+                msg = f"Lora '{path}' contains non Lora keys '{trunc(invalid_keys,200)}'"
                 error_msg = append(error_msg, msg) 
                 fail = True
             if len(unexpected_keys)  > 0:
@@ -1127,7 +1205,9 @@ def load_loras_into_model(model, lora_path, lora_multi = None, activate_all_lora
             if not check_only:
                 # model._loras_tied_weights[adapter_name] = tied_weights
                 if pinnedLora:
-                    _pin_sd_to_memory(state_dict, path)
+                    pinned_sd_list.append(state_dict)
+                    pinned_names_list.append(path)
+                    # _pin_sd_to_memory(state_dict, path)
 
             del state_dict 
 
@@ -1146,6 +1226,8 @@ def load_loras_into_model(model, lora_path, lora_multi = None, activate_all_lora
     
     model._loras_errors = errors
     if not check_only:
+        if pinnedLora and len(pinned_sd_list) > 0:
+            _pin_sd_to_memory(pinned_sd_list, pinned_names_list)
         model._loras_adapters = adapters
     if activate_all_loras:
         activate_loras(model, loras_nos, loras_multi)
@@ -1193,7 +1275,7 @@ def move_loras_to_device(model, device="cpu" ):
         if ".lora_" in k:
             m.to(device)
 
-def fast_load_transformers_model(model_path: str, do_quantize = False, quantizationType =  qint8, pinToMemory = False, partialPinning = False, forcedConfigPath = None, modelClass=None, modelPrefix = None, writable_tensors = True, verboseLevel = -1):
+def fast_load_transformers_model(model_path: str, do_quantize = False, quantizationType =  qint8, pinToMemory = False, partialPinning = False, forcedConfigPath = None, modelClass=None, modelPrefix = None, writable_tensors = True, verboseLevel = -1, configKwargs ={}):
     """
     quick version of .LoadfromPretrained of  the transformers library
     used to build a model and load the corresponding weights (quantized or not)
@@ -1235,6 +1317,7 @@ def fast_load_transformers_model(model_path: str, do_quantize = False, quantizat
             text = reader.read()
         transformer_config= json.loads(text)
 
+    transformer_config.update( configKwargs )
 
     if "architectures" in transformer_config: 
         architectures = transformer_config["architectures"]
@@ -1254,7 +1337,6 @@ def fast_load_transformers_model(model_path: str, do_quantize = False, quantizat
             fp.close()
             config_obj = AutoConfig.from_pretrained(fp.name)     
         os.remove(fp.name)
-
         #needed to keep inits of non persistent buffers
         with init_empty_weights():
             model = transfomer_class(config_obj)
@@ -1270,7 +1352,7 @@ def fast_load_transformers_model(model_path: str, do_quantize = False, quantizat
             transfomer_class = getattr(module, class_name)
 
         with init_empty_weights():
-            model = transfomer_class.from_config(transformer_config)
+            model = transfomer_class.from_config(transformer_config )
 
 
     torch.set_default_device('cpu')
@@ -1325,14 +1407,14 @@ def load_model_data(model, file_path: str, do_quantize = False, quantizationType
         if not (".safetensors" in file or ".sft" in file): 
             if pinToMemory:
                 raise Exception("Pinning to memory while loading only supported for safe tensors files")
-            state_dict = torch.load(file, weights_only=True)
+            state_dict = torch.load(file, weights_only=True, map_location="cpu")
             if "module" in state_dict:
                 state_dict = state_dict["module"]
             
         else:
             basename = os.path.basename(file)
 
-            if "model-0" in basename:
+            if "-of-" in basename:
                 metadata = None
                 file_parts= basename.split("-")
                 parts_max = int(file_parts[-1][:5])
@@ -1539,9 +1621,12 @@ class HfHook:
     def __init__(self):
         self.execution_device = "cuda"
 
-    def detach_hook(self, module):
-        pass
+    def init_hook(self, module):
+        return module
 
+    def detach_hook(self, module):
+        return module
+    
 last_offload_obj = None
 class offload:
     def __init__(self):
@@ -1650,10 +1735,9 @@ class offload:
                 lora_data = lora_module.get(adapter, None)
                 if lora_data == None:
                     continue                     
-                lora_A, lora_B, alpha = lora_data
                 key = adapter + '_GPU'
                 if to_GPU:
-                    lora_module[key] = [lora_A.cuda(non_blocking=True), lora_B.cuda(non_blocking=True), alpha]
+                    lora_module[key] = [None if item == None else item.cuda(non_blocking=True) for item in lora_data[ :-1] ] + lora_data[ -1:]
                 elif key in lora_module:
                     del lora_module[key]
             
@@ -1876,27 +1960,64 @@ class offload:
         
         return False
 
-    def _lora_linear_forward(self, model, submodule, loras_data, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+    def _get_lora_scaling(self, loras_scaling, model, active_adapter):
+        scaling_list = loras_scaling[active_adapter]
+        if isinstance(scaling_list, list):
+            step_no =getattr(model, "_lora_step_no", 0)
+            return scaling_list[step_no]
+        else:
+            return float(scaling_list)
 
-        def get_scaling(active_adapter):
-            scaling_list = loras_scaling[active_adapter]
-            if isinstance(scaling_list, list):
-                step_no =getattr(model, "_lora_step_no", 0)
-                return scaling_list[step_no]
-            else:
-                return float(scaling_list)
 
-        weight = submodule.weight
 
-        if loras_data == None:
-            return torch.nn.functional.linear(x, weight, bias=submodule.bias)
+    def _lora_generic_forward(self, model, submodule, loras_data, func, *args, **kwargs) -> torch.Tensor:
+
+        weight = submodule.weight 
+        bias =  getattr(submodule, "bias", None) 
+        original_weight = None 
+        original_bias = None
+        active_adapters = model._loras_active_adapters
+        loras_scaling = model._loras_scaling
+        first_weight =  True
+        first_bias =  True
+        for active_adapter in active_adapters:
+            data = loras_data.get(active_adapter + '_GPU', None)
+            if data == None:
+                continue
+            diff_w , _ , diff_b, alpha = data
+            if first_weight:
+                original_weight= weight.clone() if weight != None else None
+                first_weight = False
+            if first_bias:
+                original_bias= bias.clone() if bias != None else None
+                first_bias = False
+            scaling = self._get_lora_scaling( loras_scaling, model, active_adapter) * alpha
+            if diff_w != None:
+                weight.add_(diff_w, alpha= scaling)
+                diff_w = None
+            if diff_b != None:
+                bias.add_(diff_b, alpha= scaling)
+                diff_b = None
+
+        ret = func(*args, **kwargs )
+
+        weight.data  = original_weight  if original_weight != None else None 
+        if original_bias != None:
+            bias.data = original_bias
+
+        return ret
+
 
+    def _lora_linear_forward(self, model, submodule, loras_data, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        weight = submodule.weight
         active_adapters = model._loras_active_adapters
         loras_scaling = model._loras_scaling
         training = False
 
         dtype = weight.dtype 
         if weight.shape[-1] < x.shape[-2] : # sum base weight and lora matrices instead of applying input on each sub lora matrice if input is too large. This will save a lot VRAM and compute
+            bias = submodule.bias
+            original_bias = True
             if len(active_adapters) > 0:
                 if isinstance(submodule, QModuleMixin): 
                     weight = weight.view(weight.shape) # get a persistent copy of the on the fly dequantized weights
@@ -1908,16 +2029,27 @@ class offload:
                     data = loras_data.get(active_adapter + '_GPU', None)
                     if data == None:
                         continue
-                    lora_A_weight, lora_B_weight, alpha = data
-                    scaling = get_scaling(active_adapter) * alpha
-                    weight.addmm_(lora_B_weight, lora_A_weight, alpha= scaling )
+                    lora_A_weight, lora_B_weight, diff_b, alpha = data
+                    scaling = self._get_lora_scaling(loras_scaling, model, active_adapter) * alpha
+                    if lora_A_weight != None:
+                        weight.addmm_(lora_B_weight, lora_A_weight, alpha= scaling )
+                    
+                    if diff_b != None:
+                        if bias == None:
+                            bias = diff_b.clone()
+                            original_bias = False
+                        elif original_bias:
+                            bias = bias.clone()
+                            original_bias = False
+                        bias.add_(diff_b, alpha=scaling)
+
                     # base_weight += scaling * lora_B_weight @ lora_A_weight
 
             if training:
                 pass
                 # result = torch.nn.functional.linear(dropout(x), base_weight, bias=submodule.bias)
             else:
-                result = torch.nn.functional.linear(x, weight, bias=submodule.bias)
+                result = torch.nn.functional.linear(x, weight, bias=bias)
 
         else:
             result = torch.nn.functional.linear(x, weight, bias=submodule.bias)
@@ -1929,38 +2061,48 @@ class offload:
                     data = loras_data.get(active_adapter + '_GPU', None)
                     if data == None:
                         continue
-                    lora_A, lora_B, alpha = data
+                    lora_A, lora_B, diff_b, alpha = data
                     # dropout = self.lora_dropout[active_adapter]
-                    scaling = get_scaling(active_adapter) * alpha
-                    x = x.to(lora_A.dtype)
-
-                    if training:        
-                        pass                
-                        # y = lora_A(dropout(x))
+                    scaling = self._get_lora_scaling(loras_scaling, model, active_adapter) * alpha
+                    if lora_A == None:
+                        result.add_(diff_b, alpha=scaling)
                     else:
-                        y = torch.nn.functional.linear(x, lora_A, bias=None)
+                        x = x.to(lora_A.dtype)
 
-                    y = torch.nn.functional.linear(y, lora_B, bias=None)
-                    y*= scaling
-                    result+= y 
-                    del y
+                        if training:        
+                            pass                
+                            # y = lora_A(dropout(x))
+                        else:
+                            y = torch.nn.functional.linear(x, lora_A, bias=None)
+                        y = torch.nn.functional.linear(y, lora_B, bias=diff_b)
+                        y*= scaling
+                        result+= y 
+                        del y
 
         return result
 
 
-    def hook_lora_linear(self, submodule, current_model, model_id, loras_model_data, submodule_name):
+    def hook_lora(self, submodule, current_model, model_id, loras_model_data, submodule_name):
         old_forward = submodule.forward
 
         loras_data = {}
         loras_model_data[submodule] = loras_data
 
-        def  lora_linear_forward(module,  *args, **kwargs):
-            if len(loras_data) == 0:
-                return old_forward(*args, **kwargs)
-            else:
-                return self._lora_linear_forward(current_model, submodule, loras_data,  *args, **kwargs)
-
-        return functools.update_wrapper(functools.partial(lora_linear_forward, submodule), old_forward)
+        if isinstance(submodule,  torch.nn.Linear):
+            def lora_linear_forward(module,  *args, **kwargs):
+                if len(loras_data) == 0:
+                    return old_forward(*args, **kwargs)
+                else:
+                    return self._lora_linear_forward(current_model, submodule, loras_data,  *args, **kwargs)
+            target_fn = lora_linear_forward
+        else:
+            def lora_generic_forward(module,  *args, **kwargs):
+                if len(loras_data) == 0:
+                    return old_forward(*args, **kwargs)
+                else:
+                    return self._lora_generic_forward(current_model, submodule, loras_data, old_forward, *args, **kwargs)
+            target_fn = lora_generic_forward
+        return functools.update_wrapper(functools.partial(target_fn, submodule), old_forward)
 
     def ensure_model_loaded(self, model_id):
         if model_id in self.active_models_ids:
@@ -2271,7 +2413,6 @@ def all(pipe_or_dict_of_modules, pinnedMemory = False, pinnedPEFTLora = False, p
         model_dtype = getattr(current_model, "_model_dtype", None)
         # if model_dtype == None:
         #     model_dtype = getattr(current_model, "dtype", None)
-        
         for _ , m in current_model.named_modules():
             ignore_dtype = hasattr(m, "_lock_dtype")
             for n, p in m.named_parameters(recurse = False):
@@ -2413,8 +2554,9 @@ def all(pipe_or_dict_of_modules, pinnedMemory = False, pinnedPEFTLora = False, p
                           
  
             if hasattr(submodule, "forward"):
-                if  any_lora and isinstance(submodule, torch.nn.Linear):
-                    submodule_method = self.hook_lora_linear(submodule, current_model, model_id, loras_model_data, submodule_name)
+                # if  any_lora and isinstance(submodule, ( torch.nn.Linear, torch.nn.Conv3d, torch.nn.LayerNorm)):
+                if  any_lora and  hasattr(submodule,"weight"):
+                    submodule_method = self.hook_lora(submodule, current_model, model_id, loras_model_data, submodule_name)                
                 else:
                     submodule_method = getattr(submodule, "forward")
                 if callable(submodule_method):   

{mmgp-3.4.6.dist-info → mmgp-3.4.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmgp
-Version: 3.4.6
+Version: 3.4.8
 Summary: Memory Management for the GPU Poor
 Author-email: deepbeepmeep <deepbeepmeep@yahoo.com>
 Requires-Python: >=3.10
@@ -15,7 +15,7 @@ Dynamic: license-file
 
 
 <p align="center">
-  <H2>Memory Management 3.4.6 for the GPU Poor by DeepBeepMeep</H2>	
+  <H2>Memory Management 3.4.8 for the GPU Poor by DeepBeepMeep</H2>	
 </p>
 
 

mmgp-3.4.8.dist-info/RECORD

@@ -0,0 +1,9 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mmgp/__init__.py,sha256=A9qBwyQMd1M7vshSTOBnFGP1MQvS2hXmTcTCMUcmyzE,509
+mmgp/offload.py,sha256=UhILpsjJdWDv0IzOeis9KMgmPzcwZFsfPU04BLk_3To,121471
+mmgp/safetensors2.py,sha256=4nKV13qCMabnNEB1TA_ueFbfGYYmiQ9racR_C6SsGug,18693
+mmgp-3.4.8.dist-info/licenses/LICENSE.md,sha256=HjzvY2grdtdduZclbZ46B2M-XpT4MDCxFub5ZwTWq2g,93
+mmgp-3.4.8.dist-info/METADATA,sha256=Ux77MBs2BZl3fDw5BeJyOPZgyra7eyk4c4PFpmQGhtk,16309
+mmgp-3.4.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mmgp-3.4.8.dist-info/top_level.txt,sha256=waGaepj2qVfnS2yAOkaMu4r9mJaVjGbEi6AwOUogU_U,14
+mmgp-3.4.8.dist-info/RECORD,,

{mmgp-3.4.6.dist-info → mmgp-3.4.8.dist-info}/WHEEL

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

mmgp-3.4.6.dist-info/RECORD

@@ -1,9 +0,0 @@
-__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mmgp/__init__.py,sha256=A9qBwyQMd1M7vshSTOBnFGP1MQvS2hXmTcTCMUcmyzE,509
-mmgp/offload.py,sha256=2oWFiDcwIx3lGOb_6_aac1zzIIF-nhP8bwOA-G9HxsU,114594
-mmgp/safetensors2.py,sha256=4nKV13qCMabnNEB1TA_ueFbfGYYmiQ9racR_C6SsGug,18693
-mmgp-3.4.6.dist-info/licenses/LICENSE.md,sha256=HjzvY2grdtdduZclbZ46B2M-XpT4MDCxFub5ZwTWq2g,93
-mmgp-3.4.6.dist-info/METADATA,sha256=kv9OfYHAAHKyiv9p9vrf4guU3tNd0I7vUgQ6xm7dkk8,16309
-mmgp-3.4.6.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-mmgp-3.4.6.dist-info/top_level.txt,sha256=waGaepj2qVfnS2yAOkaMu4r9mJaVjGbEi6AwOUogU_U,14
-mmgp-3.4.6.dist-info/RECORD,,