Apply style fixes

Author: nandan2003

src/transformers/integrations/peft.py

@@ -205,48 +205,28 @@ def load_adapter(
         if hotswap == "auto":
             # if user called model.enable_peft_hotswap and this is not the first adapter, enable hotswap
             hotswap_enabled = getattr(self, "_hotswap_enabled", False)
-            not_first_adapter = bool(
-                self._hf_peft_config_loaded and (adapter_name in self.peft_config)
-            )
+            not_first_adapter = bool(self._hf_peft_config_loaded and (adapter_name in self.peft_config))
             hotswap = hotswap_enabled and not_first_adapter
 
         if hotswap:
             min_version_hotswap = "0.15.0"
-            if version.parse(importlib.metadata.version("peft")) < version.parse(
-                min_version_hotswap
-            ):
-                raise ValueError(
-                    f"To hotswap the adapter, you need PEFT >= v{min_version_hotswap}."
-                )
-            if (not self._hf_peft_config_loaded) or (
-                adapter_name not in self.peft_config
-            ):
+            if version.parse(importlib.metadata.version("peft")) < version.parse(min_version_hotswap):
+                raise ValueError(f"To hotswap the adapter, you need PEFT >= v{min_version_hotswap}.")
+            if (not self._hf_peft_config_loaded) or (adapter_name not in self.peft_config):
                 raise ValueError(
                     "To hotswap an adapter, there must already be an existing adapter with the same adapter name."
                 )
-            if any(
-                conf.peft_type != PeftType.LORA for conf in self.peft_config.values()
-            ):
-                raise ValueError(
-                    "Hotswapping is currently only supported for LoRA, please set `hotswap=False`."
-                )
+            if any(conf.peft_type != PeftType.LORA for conf in self.peft_config.values()):
+                raise ValueError("Hotswapping is currently only supported for LoRA, please set `hotswap=False`.")
 
         # peft only supports low_cpu_mem_usage starting from v0.13.0
         peft_load_kwargs = {}
-        key_mapping = (
-            adapter_kwargs.pop("key_mapping", None)
-            if adapter_kwargs is not None
-            else None
-        )
-        if key_mapping is None and any(
-            allowed_name in self.__class__.__name__.lower() for allowed_name in VLMS
-        ):
+        key_mapping = adapter_kwargs.pop("key_mapping", None) if adapter_kwargs is not None else None
+        if key_mapping is None and any(allowed_name in self.__class__.__name__.lower() for allowed_name in VLMS):
             key_mapping = self._checkpoint_conversion_mapping
         if low_cpu_mem_usage:
             min_version_lcmu = "0.13.0"
-            if version.parse(importlib.metadata.version("peft")) >= version.parse(
-                min_version_lcmu
-            ):
+            if version.parse(importlib.metadata.version("peft")) >= version.parse(min_version_lcmu):
                 peft_load_kwargs["low_cpu_mem_usage"] = low_cpu_mem_usage
             else:
                 raise ValueError(
@@ -264,34 +244,20 @@ def load_adapter(
         from peft import PeftConfig, inject_adapter_in_model, load_peft_weights
         from peft.utils import set_peft_model_state_dict
 
-        if (
-            self._hf_peft_config_loaded
-            and (not hotswap)
-            and (adapter_name in self.peft_config)
-        ):
-            raise ValueError(
-                f"Adapter with name {adapter_name} already exists. Please use a different name."
-            )
-        elif hotswap and (
-            (not self._hf_peft_config_loaded) or (adapter_name not in self.peft_config)
-        ):
+        if self._hf_peft_config_loaded and (not hotswap) and (adapter_name in self.peft_config):
+            raise ValueError(f"Adapter with name {adapter_name} already exists. Please use a different name.")
+        elif hotswap and ((not self._hf_peft_config_loaded) or (adapter_name not in self.peft_config)):
             raise ValueError(
                 "To hotswap an adapter, there must already be an existing adapter with the same adapter name."
             )
 
-        if peft_model_id is None and (
-            adapter_state_dict is None and peft_config is None
-        ):
+        if peft_model_id is None and (adapter_state_dict is None and peft_config is None):
             raise ValueError(
                 "You should either pass a `peft_model_id` or a `peft_config` and `adapter_state_dict` to load an adapter."
             )
 
         if "device" not in adapter_kwargs:
-            device = (
-                self.device
-                if not hasattr(self, "hf_device_map")
-                else list(self.hf_device_map.values())[0]
-            )
+            device = self.device if not hasattr(self, "hf_device_map") else list(self.hf_device_map.values())[0]
         else:
             device = adapter_kwargs.pop("device")
 
@@ -302,11 +268,7 @@ def load_adapter(
         # We keep `revision` in the signature for backward compatibility
         if revision is not None and "revision" not in adapter_kwargs:
             adapter_kwargs["revision"] = revision
-        elif (
-            revision is not None
-            and "revision" in adapter_kwargs
-            and revision != adapter_kwargs["revision"]
-        ):
+        elif revision is not None and "revision" in adapter_kwargs and revision != adapter_kwargs["revision"]:
             logger.error(
                 "You passed a `revision` argument both in `adapter_kwargs` and as a standalone argument. "
                 "The one in `adapter_kwargs` will be used."
@@ -337,9 +299,7 @@ def load_adapter(
             peft_config.inference_mode = not is_trainable
 
         if peft_config.peft_type != PeftType.LORA:
-            raise ValueError(
-                "Hotswapping is currently only supported for LoRA, please set `hotswap=False`."
-            )
+            raise ValueError("Hotswapping is currently only supported for LoRA, please set `hotswap=False`.")
 
         if not hotswap:
             # TODO: WE NEED TOO APPLY OUR DYNAMIC WEIGHT CONVERSION AT SOME POINT HERE!
@@ -350,9 +310,7 @@ def load_adapter(
             self._hf_peft_config_loaded = True
 
         if peft_model_id is not None:
-            adapter_state_dict = load_peft_weights(
-                peft_model_id, token=token, device=device, **adapter_kwargs
-            )
+            adapter_state_dict = load_peft_weights(peft_model_id, token=token, device=device, **adapter_kwargs)
 
         # We need to pre-process the state dict to remove unneeded prefixes - for backward compatibility
         processed_adapter_state_dict = {}
@@ -392,9 +350,7 @@ def load_adapter(
                 # Therefore, it needs to be called here
                 from peft.utils.hotswap import prepare_model_for_compiled_hotswap
 
-                prepare_model_for_compiled_hotswap(
-                    self, config=peft_config, **self._prepare_peft_hotswap_kwargs
-                )
+                prepare_model_for_compiled_hotswap(self, config=peft_config, **self._prepare_peft_hotswap_kwargs)
                 # We only want to call prepare_model_for_compiled_hotswap once
                 self._prepare_peft_hotswap_kwargs = None
         else:
@@ -403,9 +359,7 @@ def load_adapter(
                 hotswap_adapter_from_state_dict,
             )
 
-            check_hotswap_configs_compatible(
-                self.peft_config[adapter_name], peft_config
-            )
+            check_hotswap_configs_compatible(self.peft_config[adapter_name], peft_config)
             try:
                 hotswap_adapter_from_state_dict(
                     model=self,
@@ -414,20 +368,15 @@ def load_adapter(
                     config=peft_config,
                 )
             except Exception as e:
-                logger.error(
-                    f"Hotswapping {adapter_name} was unsucessful with the following error: \n{e}"
-                )
+                logger.error(f"Hotswapping {adapter_name} was unsucessful with the following error: \n{e}")
                 raise
             incompatible_keys = None
 
         if incompatible_keys is not None:
             err_msg = ""
             origin_name = peft_model_id if peft_model_id is not None else "state_dict"
             # Check for unexpected keys.
-            if (
-                hasattr(incompatible_keys, "unexpected_keys")
-                and len(incompatible_keys.unexpected_keys) > 0
-            ):
+            if hasattr(incompatible_keys, "unexpected_keys") and len(incompatible_keys.unexpected_keys) > 0:
                 err_msg = (
                     f"Loading adapter weights from {origin_name} led to unexpected keys not found in the model: "
                     f"{', '.join(incompatible_keys.unexpected_keys)}. "
@@ -437,9 +386,7 @@ def load_adapter(
             missing_keys = getattr(incompatible_keys, "missing_keys", None)
             if missing_keys:
                 # Filter missing keys specific to the current adapter, as missing base model keys are expected.
-                lora_missing_keys = [
-                    k for k in missing_keys if "lora_" in k and adapter_name in k
-                ]
+                lora_missing_keys = [k for k in missing_keys if "lora_" in k and adapter_name in k]
                 if lora_missing_keys:
                     err_msg += (
                         f"Loading adapter weights from {origin_name} led to missing keys in the model: "
@@ -455,9 +402,7 @@ def load_adapter(
         # Re-dispatch model and hooks in case the model is offloaded to CPU / Disk.
         if (
             (getattr(self, "hf_device_map", None) is not None)
-            and (
-                len(set(self.hf_device_map.values()).intersection({"cpu", "disk"})) > 0
-            )
+            and (len(set(self.hf_device_map.values()).intersection({"cpu", "disk"})) > 0)
             and len(self.peft_config) == 1
         ):
             self._dispatch_accelerate_model(
@@ -492,18 +437,12 @@ def enable_peft_hotswap(
                   - "ignore": do nothing
         """
         min_version_hotswap = "0.15.0"
-        if version.parse(importlib.metadata.version("peft")) < version.parse(
-            min_version_hotswap
-        ):
-            raise ValueError(
-                f"To hotswap the adapter, you need PEFT >= v{min_version_hotswap}."
-            )
+        if version.parse(importlib.metadata.version("peft")) < version.parse(min_version_hotswap):
+            raise ValueError(f"To hotswap the adapter, you need PEFT >= v{min_version_hotswap}.")
 
         if getattr(self, "peft_config", {}):
             if check_compiled == "error":
-                raise RuntimeError(
-                    "Call `enable_peft_hotswap` before loading the first adapter."
-                )
+                raise RuntimeError("Call `enable_peft_hotswap` before loading the first adapter.")
             elif check_compiled == "warn":
                 logger.warning(
                     "It is recommended to call `enable_peft_hotswap` before loading the first adapter to avoid recompilation."
@@ -546,14 +485,10 @@ def add_adapter(self, adapter_config, adapter_name: str | None = None) -> None:
         if not self._hf_peft_config_loaded:
             self._hf_peft_config_loaded = True
         elif adapter_name in self.peft_config:
-            raise ValueError(
-                f"Adapter with name {adapter_name} already exists. Please use a different name."
-            )
+            raise ValueError(f"Adapter with name {adapter_name} already exists. Please use a different name.")
 
         if not isinstance(adapter_config, PeftConfig):
-            raise TypeError(
-                f"adapter_config should be an instance of PeftConfig. Got {type(adapter_config)} instead."
-            )
+            raise TypeError(f"adapter_config should be an instance of PeftConfig. Got {type(adapter_config)} instead.")
 
         # Retrieve the name or path of the model, one could also use self.config._name_or_path
         # but to be consistent with what we do in PEFT: https://github.com/huggingface/peft/blob/6e783780ca9df3a623992cc4d1d665001232eae0/src/peft/mapping.py#L100
@@ -667,9 +602,7 @@ def active_adapters(self) -> list[str]:
         check_peft_version(min_version=MIN_PEFT_VERSION)
 
         if not is_peft_available():
-            raise ImportError(
-                "PEFT is not available. Please install PEFT to use this function: `pip install peft`."
-            )
+            raise ImportError("PEFT is not available. Please install PEFT to use this function: `pip install peft`.")
 
         if not self._hf_peft_config_loaded:
             raise ValueError("No adapter loaded. Please load an adapter first.")
@@ -687,9 +620,7 @@ def active_adapters(self) -> list[str]:
 
         return active_adapters
 
-    def get_adapter_state_dict(
-        self, adapter_name: Optional[str] = None, state_dict: Optional[dict] = None
-    ) -> dict:
+    def get_adapter_state_dict(self, adapter_name: Optional[str] = None, state_dict: Optional[dict] = None) -> dict:
         """
         If you are not familiar with adapters and PEFT methods, we invite you to read more about them on the PEFT
         official documentation: https://huggingface.co/docs/peft
@@ -715,9 +646,7 @@ def get_adapter_state_dict(
         if adapter_name is None:
             adapter_name = self.active_adapters()[0]
 
-        adapter_state_dict = get_peft_model_state_dict(
-            self, state_dict=state_dict, adapter_name=adapter_name
-        )
+        adapter_state_dict = get_peft_model_state_dict(self, state_dict=state_dict, adapter_name=adapter_name)
         return adapter_state_dict
 
     def _dispatch_accelerate_model(
@@ -817,9 +746,7 @@ def old_delete_adapter(model, adapter_name, prefix=None):
                     f">= {min_version_delete_adapter} is required."
                 )
 
-        if version.parse(importlib.metadata.version("peft")) >= version.parse(
-            min_version_delete_adapter
-        ):
+        if version.parse(importlib.metadata.version("peft")) >= version.parse(min_version_delete_adapter):
             from peft.functional import delete_adapter
         else:
             delete_adapter = old_delete_adapter
@@ -828,24 +755,17 @@ def old_delete_adapter(model, adapter_name, prefix=None):
             adapter_names = [adapter_names]
 
         # Check that all adapter names are present in the config
-        missing_adapters = [
-            name for name in adapter_names if name not in self.peft_config
-        ]
+        missing_adapters = [name for name in adapter_names if name not in self.peft_config]
         if missing_adapters:
             raise ValueError(
                 f"The following adapter(s) are not present and cannot be deleted: {', '.join(missing_adapters)}"
             )
 
-        prefixes = [
-            f"{self.peft_config[adapter_name].peft_type.value.lower()}_"
-            for adapter_name in adapter_names
-        ]
+        prefixes = [f"{self.peft_config[adapter_name].peft_type.value.lower()}_" for adapter_name in adapter_names]
         for adapter_name, prefix in zip(adapter_names, prefixes):
             delete_adapter(self, adapter_name=adapter_name, prefix=prefix)
             # For transformers integration - we need to pop the adapter from the config
-            if getattr(self, "_hf_peft_config_loaded", False) and hasattr(
-                self, "peft_config"
-            ):
+            if getattr(self, "_hf_peft_config_loaded", False) and hasattr(self, "peft_config"):
                 self.peft_config.pop(adapter_name, None)
 
         # In case all adapters are deleted, we need to delete the config
@@ -864,9 +784,7 @@ def maybe_load_adapters(
         return None, pretrained_model_name_or_path, adapter_kwargs
 
     if "local_files_only" not in adapter_kwargs:
-        adapter_kwargs["local_files_only"] = download_kwargs.get(
-            "local_files_only", False
-        )
+        adapter_kwargs["local_files_only"] = download_kwargs.get("local_files_only", False)
 
     token = download_kwargs.get("token")
 
@@ -902,12 +820,8 @@ def maybe_load_adapters(
                 peft_kwargs[arg_name] = download_kwargs[arg_name]
         if "commit_hash" in download_kwargs:
             peft_kwargs["_commit_hash"] = download_kwargs["commit_hash"]
-        peft_kwargs["force_download"] = bool(
-            download_kwargs.get("force_download", False)
-        )
-        peft_kwargs["local_files_only"] = bool(
-            download_kwargs.get("local_files_only", False)
-        )
+        peft_kwargs["force_download"] = bool(download_kwargs.get("force_download", False))
+        peft_kwargs["local_files_only"] = bool(download_kwargs.get("local_files_only", False))
         peft_kwargs["token"] = token or token_from_adapter_kwargs
         _adapter_model_path = find_adapter_config_file(
             pretrained_model_name_or_path,