[pre-commit.ci] pre-commit suggestions (#2009)

pre-commit-ci[bot] · Borda · web-flow · commit 048633a7d08f · 2025-04-08T10:13:12.000Z
Co-authored-by: pre-commit-ci[bot] &lt;66853113+pre-commit-ci[bot]@users.noreply.github.com&gt;
Co-authored-by: Jirka Borovec &lt;6035284+Borda@users.noreply.github.com&gt;
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -37,7 +37,7 @@ repos:
       - id: detect-private-key
 
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.3.0
+    rev: v2.4.1
     hooks:
       - id: codespell
         additional_dependencies: [tomli]
@@ -70,19 +70,19 @@ repos:
         args: ["--print-width=140"]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.6
+    rev: v0.11.4
     hooks:
       - id: ruff
         args: ["--fix"]
       - id: ruff-format
       - id: ruff
 
   - repo: https://github.com/tox-dev/pyproject-fmt
-    rev: v2.5.0
+    rev: v2.5.1
     hooks:
       - id: pyproject-fmt
         additional_dependencies: [tox]
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.23
+    rev: v0.24.1
     hooks:
       - id: validate-pyproject
diff --git a/extensions/thunder/pretrain.py b/extensions/thunder/pretrain.py
@@ -256,7 +256,7 @@ def main(
         eval=eval,
         optimizer=optimizer,
     )
-    fabric.print(f"Training time: {(time.perf_counter()-train_time):.2f}s")
+    fabric.print(f"Training time: {(time.perf_counter() - train_time):.2f}s")
 
     # Save final checkpoint
     save_checkpoint(fabric, state, tokenizer_dir, out_dir / "final" / "lit_model.pth")
@@ -364,7 +364,7 @@ def fit(
             if isinstance(val_loss, float):
                 val_loss = f"{val_loss:.3f}"
             fabric.print(
-                f"Epoch {metrics['epoch']+1} | iter {metrics['iter']} step {metrics['step']} |"
+                f"Epoch {metrics['epoch'] + 1} | iter {metrics['iter']} step {metrics['step']} |"
                 f" loss train: {metrics['loss']:.3f},"
                 f" val: {val_loss} |"
                 f" iter time: {metrics['iter_time'] * 1000:.2f} ms"
diff --git a/extensions/thunder/unsloth/kernels/utils.py b/extensions/thunder/unsloth/kernels/utils.py
@@ -26,7 +26,7 @@ def calculate_settings(n):
     BLOCK_SIZE = next_power_of_2(n)
     if BLOCK_SIZE > MAX_FUSED_SIZE:
         raise RuntimeError(
-            f"Cannot launch Triton kernel since n = {n} exceeds " f"the maximum CUDA blocksize = {MAX_FUSED_SIZE}."
+            f"Cannot launch Triton kernel since n = {n} exceeds the maximum CUDA blocksize = {MAX_FUSED_SIZE}."
         )
     num_warps = 4
     if BLOCK_SIZE >= 32768:
diff --git a/extensions/xla/finetune/adapter.py b/extensions/xla/finetune/adapter.py
@@ -112,7 +112,7 @@ def main(fabric: L.Fabric, data_dir: Path, checkpoint_dir: Path, out_dir: Path)
 
     train_time = time.perf_counter()
     train(fabric, model, optimizer, train_data, val_data, checkpoint_dir, out_dir)
-    rank_print(fabric, f"Training time: {(time.perf_counter()-train_time):.2f}s")
+    rank_print(fabric, f"Training time: {(time.perf_counter() - train_time):.2f}s")
 
     # Save the final checkpoint at the end of training
     save_path = out_dir / "lit_model_adapter_finetuned.pth"
diff --git a/litgpt/api.py b/litgpt/api.py
@@ -677,7 +677,7 @@ def print_table(header, data):
                 mean_str = "N/A"
                 std_dev_str = "N/A"
 
-            markdown_table += f"| {key:<36} | {first_iteration:<15} | " f"{mean_str:<17} | {std_dev_str:<23} |\n"
+            markdown_table += f"| {key:<36} | {first_iteration:<15} | {mean_str:<17} | {std_dev_str:<23} |\n"
         print(markdown_table)
 
     import subprocess
diff --git a/litgpt/chat/base.py b/litgpt/chat/base.py
@@ -114,8 +114,7 @@ def process_prompt(
     for block in model.transformer.h:
         block.attn.kv_cache.reset_parameters()
     fabric.print(
-        f"\nTime for inference: {t:.02f} sec total, {tokens_generated / t:.02f} tokens/sec,"
-        f" {tokens_generated} tokens",
+        f"\nTime for inference: {t:.02f} sec total, {tokens_generated / t:.02f} tokens/sec, {tokens_generated} tokens",
         file=sys.stderr,
     )
     fabric.print()
diff --git a/litgpt/finetune/adapter.py b/litgpt/finetune/adapter.py
@@ -103,7 +103,7 @@ def setup(
             raise ValueError("Quantization and mixed precision is not supported.")
         if RequirementCache("bitsandbytes != 0.42.0"):
             warnings.warn(
-                "LitGPT only supports bitsandbytes v0.42.0. " "This may result in errors when using quantization."
+                "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."
             )
         dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
         plugins = BitsandbytesPrecision(quantize[4:], dtype)
diff --git a/litgpt/finetune/adapter_v2.py b/litgpt/finetune/adapter_v2.py
@@ -105,7 +105,7 @@ def setup(
             raise ValueError("Quantization and mixed precision is not supported.")
         if RequirementCache("bitsandbytes != 0.42.0"):
             warnings.warn(
-                "LitGPT only supports bitsandbytes v0.42.0. " "This may result in errors when using quantization."
+                "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."
             )
         dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
         plugins = BitsandbytesPrecision(quantize[4:], dtype)
diff --git a/litgpt/finetune/full.py b/litgpt/finetune/full.py
@@ -307,7 +307,7 @@ def fit(
             if isinstance(val_loss, torch.Tensor):
                 val_loss = f"{val_loss:.3f}"
             fabric.print(
-                f"Epoch {metrics['epoch']+1} | iter {metrics['iter']} step {metrics['step']} |"
+                f"Epoch {metrics['epoch'] + 1} | iter {metrics['iter']} step {metrics['step']} |"
                 f" loss train: {metrics['loss']:.3f},"
                 f" val: {val_loss} |"
                 f" iter time: {metrics['iter_time'] * 1000:.2f} ms"
diff --git a/litgpt/finetune/lora.py b/litgpt/finetune/lora.py
@@ -133,7 +133,7 @@ def setup(
             raise ValueError("Quantization and mixed precision is not supported.")
         if RequirementCache("bitsandbytes != 0.42.0"):
             warnings.warn(
-                "LitGPT only supports bitsandbytes v0.42.0. " "This may result in errors when using quantization."
+                "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."
             )
         dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
         plugins = BitsandbytesPrecision(quantize[4:], dtype)
@@ -366,7 +366,7 @@ def fit(
             if isinstance(val_loss, torch.Tensor):
                 val_loss = f"{val_loss:.3f}"
             fabric.print(
-                f"Epoch {metrics['epoch']+1} | iter {metrics['iter']} step {metrics['step']} |"
+                f"Epoch {metrics['epoch'] + 1} | iter {metrics['iter']} step {metrics['step']} |"
                 f" loss train: {metrics['loss']:.3f},"
                 f" val: {val_loss} |"
                 f" iter time: {metrics['iter_time'] * 1000:.2f} ms"
diff --git a/litgpt/generate/adapter.py b/litgpt/generate/adapter.py
@@ -83,7 +83,7 @@ def main(
             raise ValueError("Quantization and mixed precision is not supported.")
         if RequirementCache("bitsandbytes != 0.42.0"):
             warnings.warn(
-                "LitGPT only supports bitsandbytes v0.42.0. " "This may result in errors when using quantization."
+                "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."
             )
         dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
         plugins = BitsandbytesPrecision(quantize[4:], dtype)
diff --git a/litgpt/generate/adapter_v2.py b/litgpt/generate/adapter_v2.py
@@ -83,7 +83,7 @@ def main(
             raise ValueError("Quantization and mixed precision is not supported.")
         if RequirementCache("bitsandbytes != 0.42.0"):
             warnings.warn(
-                "LitGPT only supports bitsandbytes v0.42.0. " "This may result in errors when using quantization."
+                "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."
             )
         dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
         plugins = BitsandbytesPrecision(quantize[4:], dtype)
diff --git a/litgpt/generate/base.py b/litgpt/generate/base.py
@@ -157,9 +157,9 @@ def generate_fn(
     prompt_size = prompt.size(0)
     device = prompt.device
 
-    assert (
-        max_returned_tokens > prompt_size
-    ), f"Not enough space for {prompt_size} prompt tokens in a context length of {max_returned_tokens}."
+    assert max_returned_tokens > prompt_size, (
+        f"Not enough space for {prompt_size} prompt tokens in a context length of {max_returned_tokens}."
+    )
     if model.max_seq_length < max_returned_tokens - 1:
         raise NotImplementedError(f"max_seq_length {model.max_seq_length} needs to be >= {max_returned_tokens - 1}")
 
@@ -281,9 +281,9 @@ def batched_generate_fn(
         assert len(sample_args) == batch_size, "sample_args must have the length as the batch size."
 
     # TODO: This check (and the one in generate_fn) is not sufficient. We do the proper checks in LLM.generate().
-    assert (
-        max_returned_tokens > max_prompt_size
-    ), f"Not enough space for {max_prompt_size} prompt tokens in a context length of {max_returned_tokens}."
+    assert max_returned_tokens > max_prompt_size, (
+        f"Not enough space for {max_prompt_size} prompt tokens in a context length of {max_returned_tokens}."
+    )
     if model.max_seq_length < max_returned_tokens - 1:
         raise NotImplementedError(f"max_seq_length {model.max_seq_length} needs to be >= {max_returned_tokens - 1}")
 
@@ -488,7 +488,7 @@ def main(
             raise ValueError("Quantization and mixed precision is not supported.")
         if RequirementCache("bitsandbytes != 0.42.0"):
             warnings.warn(
-                "LitGPT only supports bitsandbytes v0.42.0. " "This may result in errors when using quantization."
+                "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."
             )
         dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
         plugins = BitsandbytesPrecision(quantize[4:], dtype)
diff --git a/litgpt/generate/full.py b/litgpt/generate/full.py
@@ -82,7 +82,7 @@ def main(
             raise ValueError("Quantization and mixed precision is not supported.")
         if RequirementCache("bitsandbytes != 0.42.0"):
             warnings.warn(
-                "LitGPT only supports bitsandbytes v0.42.0. " "This may result in errors when using quantization."
+                "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."
             )
         dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
         plugins = BitsandbytesPrecision(quantize[4:], dtype)
diff --git a/litgpt/generate/sequentially.py b/litgpt/generate/sequentially.py
@@ -192,7 +192,7 @@ def main(
             raise ValueError("Quantization and mixed precision is not supported.")
         if RequirementCache("bitsandbytes != 0.42.0"):
             warnings.warn(
-                "LitGPT only supports bitsandbytes v0.42.0. " "This may result in errors when using quantization."
+                "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."
             )
         dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
         logging.getLogger("lightning.fabric.plugins.precision.bitsandbytes").setLevel(logging.DEBUG)
diff --git a/litgpt/generate/speculative_decoding.py b/litgpt/generate/speculative_decoding.py
@@ -214,9 +214,9 @@ def generate(
     prompt_size = prompt.size(0)
     device = prompt.device
 
-    assert (
-        max_returned_tokens > prompt_size
-    ), f"Not enough space for {prompt_size} prompt tokens in a context length of {max_returned_tokens}."
+    assert max_returned_tokens > prompt_size, (
+        f"Not enough space for {prompt_size} prompt tokens in a context length of {max_returned_tokens}."
+    )
     if draft_model.max_seq_length < max_returned_tokens - 1:
         raise NotImplementedError(
             f"max_seq_length {draft_model.max_seq_length} needs to be >= {max_returned_tokens - 1}"
diff --git a/litgpt/generate/tp.py b/litgpt/generate/tp.py
@@ -158,7 +158,7 @@ def main(
             raise ValueError("Quantization and mixed precision is not supported.")
         if RequirementCache("bitsandbytes != 0.42.0"):
             warnings.warn(
-                "LitGPT only supports bitsandbytes v0.42.0. " "This may result in errors when using quantization."
+                "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."
             )
         dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
         bnb_logger = logging.getLogger("lightning.fabric.plugins.precision.bitsandbytes")
diff --git a/litgpt/pretrain.py b/litgpt/pretrain.py
@@ -251,7 +251,7 @@ def main(
     fabric.print(separator)
     fabric.print("| Performance")
     fabric.print(f"| - Total tokens  : {total_tokens:,}")
-    fabric.print(f"| - Training Time : {(time.perf_counter()-train_time):.2f} s")
+    fabric.print(f"| - Training Time : {(time.perf_counter() - train_time):.2f} s")
     fabric.print(f"| - Tok/sec       : {total_tokens / train_time:.2f} tok/s")
     fabric.print("| " + "-" * 40)
 
@@ -366,7 +366,7 @@ def fit(
             if isinstance(val_loss, float):
                 val_loss = f"{val_loss:.3f}"
             fabric.print(
-                f"Epoch {metrics['epoch']+1} | iter {metrics['iter']} step {metrics['step']} |"
+                f"Epoch {metrics['epoch'] + 1} | iter {metrics['iter']} step {metrics['step']} |"
                 f" loss train: {metrics['loss']:.3f},"
                 f" val: {val_loss} |"
                 f" iter time: {metrics['iter_time'] * 1000:.2f} ms"
diff --git a/litgpt/prompts.py b/litgpt/prompts.py
@@ -146,9 +146,7 @@ def apply(self, prompt: str, **kwargs: str) -> str:
         # replace the curly braces with double curly braces to escape them
         function_list = dumps(function_metadata).replace("{", "{{").replace("}", "}}")
         return (
-            f"{b_func}{function_list.strip()}{e_func}{b_inst}{b_sys}"
-            f"{system_prompt.strip()}"
-            f"{e_sys}{prompt}{e_inst}\n\n"
+            f"{b_func}{function_list.strip()}{e_func}{b_inst}{b_sys}{system_prompt.strip()}{e_sys}{prompt}{e_inst}\n\n"
         )
 
 
@@ -225,9 +223,7 @@ def apply(self, prompt: Union[str, List[Dict[str, str]]], **kwargs: str) -> str:
         eos_token = ""
 
         if isinstance(prompt, str):
-            return (
-                f"{default_system_prompt}" f"<｜User｜>{prompt}" f"<｜Assistant｜>"  # Prepares for assistant response
-            )
+            return f"{default_system_prompt}<｜User｜>{prompt}<｜Assistant｜>"  # Prepares for assistant response
         elif isinstance(prompt, list):
 
             def encode_message(message: Dict[str, str]) -> str:
diff --git a/litgpt/utils.py b/litgpt/utils.py
@@ -173,16 +173,16 @@ def __init__(self, tensor, saver, protocol_version=5):
         if reduce_args[0] == torch._utils._rebuild_tensor_v2:
             # for Tensors with Python attributes
             (a0, a1, (storage, *a2_other), *other_reduce_args) = reduce_args
-            assert isinstance(
-                storage, (torch.storage.TypedStorage, torch.storage.UntypedStorage)
-            ), "Please check for updates"
+            assert isinstance(storage, (torch.storage.TypedStorage, torch.storage.UntypedStorage)), (
+                "Please check for updates"
+            )
             storage_proxy = SavingProxyForStorage(storage, saver, protocol_version=protocol_version)
             self.reduce_args = (a0, a1, (storage_proxy, *a2_other), *other_reduce_args)
         else:
             (storage, *other_reduce_args) = reduce_args
-            assert isinstance(
-                storage, (torch.storage.TypedStorage, torch.storage.UntypedStorage)
-            ), "Please check for updates"
+            assert isinstance(storage, (torch.storage.TypedStorage, torch.storage.UntypedStorage)), (
+                "Please check for updates"
+            )
             storage_proxy = SavingProxyForStorage(storage, saver, protocol_version=protocol_version)
             self.reduce_args = (storage_proxy, *other_reduce_args)
 
@@ -642,7 +642,7 @@ def check_file_size_on_cpu_and_warn(checkpoint_path, device, size_limit=4_509_71
         size = os.path.getsize(checkpoint_path)
         if size > size_limit and str(device) == "cpu":
             warnings.warn(
-                f"The file size of {checkpoint_path} is over {size_limit/1024/1024/1024:.1f} GB. Using a model "
+                f"The file size of {checkpoint_path} is over {size_limit / 1024 / 1024 / 1024:.1f} GB. Using a model "
                 "with more than 1B parameters on a CPU can be slow, it is recommended to switch to a GPU."
             )
     return size
diff --git a/tests/test_api.py b/tests/test_api.py
@@ -127,12 +127,12 @@ def test_llm_load_hub_init(tmp_path):
 
 def test_model_not_initialized(tmp_path):
     llm = LLM.load(model="EleutherAI/pythia-14m", init="pretrained", distribute=None)
-    s = "The model is not initialized yet; use the .distribute() " "or .trainer_setup() method to initialize the model."
+    s = "The model is not initialized yet; use the .distribute() or .trainer_setup() method to initialize the model."
     with pytest.raises(AttributeError, match=re.escape(s)):
         llm.generate("text")
 
     llm = LLM.load(model="EleutherAI/pythia-14m", tokenizer_dir="EleutherAI/pythia-14m", init="random", distribute=None)
-    s = "The model is not initialized yet; use the .distribute() " "or .trainer_setup() method to initialize the model."
+    s = "The model is not initialized yet; use the .distribute() or .trainer_setup() method to initialize the model."
     with pytest.raises(AttributeError, match=re.escape(s)):
         llm.generate("text")
 
@@ -166,7 +166,7 @@ def test_more_than_1_device_for_sequential_gpu(tmp_path):
     llm.distribute(generate_strategy="sequential")
     assert isinstance(llm.generate("What do llamas eat?"), str)
     assert str(llm.model.transformer.h[0].mlp.fc.weight.device) == "cuda:0"
-    assert str(llm.model.transformer.h[last_layer_idx].mlp.fc.weight.device) == f"cuda:{device_count-1}"
+    assert str(llm.model.transformer.h[last_layer_idx].mlp.fc.weight.device) == f"cuda:{device_count - 1}"
 
 
 @_RunIf(min_cuda_gpus=2)
@@ -211,7 +211,7 @@ def test_sequential_tp_cpu(tmp_path):
 
 def test_initialization_for_trainer(tmp_path):
     llm = LLM.load(model="EleutherAI/pythia-14m", distribute=None)
-    s = "The model is not initialized yet; use the .distribute() " "or .trainer_setup() method to initialize the model."
+    s = "The model is not initialized yet; use the .distribute() or .trainer_setup() method to initialize the model."
     with pytest.raises(AttributeError, match=re.escape(s)):
         llm.generate("hello world")
 
@@ -411,6 +411,6 @@ def test_precision_selection(tmp_path):
     llm = LLM.load(model="EleutherAI/pythia-14m", init="pretrained")
 
     llm.distribute(precision="16-true")
-    assert (
-        llm.model._forward_module.lm_head.weight.dtype == torch.float16
-    ), f"Expected float16, but got {llm.model._forward_module.lm_head.weight.dtype}"
+    assert llm.model._forward_module.lm_head.weight.dtype == torch.float16, (
+        f"Expected float16, but got {llm.model._forward_module.lm_head.weight.dtype}"
+    )
diff --git a/tests/test_chat.py b/tests/test_chat.py
@@ -197,6 +197,6 @@ def test_litgpt_generate_endtoend():
             pass
 
     # pythia-14m is not instruct-tuned, so it does not give an "answer" per se, but a continuation.
-    assert (
-        "Hello World!" in captured_output.getvalue()
-    ), f"Expected output not found. Got:\n{captured_output.getvalue()}"
+    assert "Hello World!" in captured_output.getvalue(), (
+        f"Expected output not found. Got:\n{captured_output.getvalue()}"
+    )
diff --git a/tests/test_utils.py b/tests/test_utils.py
@@ -331,9 +331,9 @@ def test_init_out_dir(path_type, input_path, expected):
         if "LIGHTNING_ARTIFACTS_DIR" not in os.environ:
             assert result == Path(expected), f"Failed for {path_type} with input {input_path} (result {result})"
         else:
-            assert (
-                result == Path(os.getenv("LIGHTNING_ARTIFACTS_DIR")) / expected
-            ), f"Failed for {path_type} with input {input_path} (result {result})"
+            assert result == Path(os.getenv("LIGHTNING_ARTIFACTS_DIR")) / expected, (
+                f"Failed for {path_type} with input {input_path} (result {result})"
+            )
 
 
 def test_find_resume_path(tmp_path):
diff --git a/tutorials/full_finetune_example.py b/tutorials/full_finetune_example.py
@@ -42,7 +42,7 @@ def validate(model, val_dataloader):
             logits = logits.reshape(-1, logits.size(-1))
             targets = targets.reshape(-1)
             loss += nn.functional.cross_entropy(logits[..., :-1, :], targets[..., 1:])
-    fabric.print(f"Validation loss: {loss/len(val_dataloader)}")
+    fabric.print(f"Validation loss: {loss / len(val_dataloader)}")
 
 
 def train(fabric, model, optimizer, scheduler, train_dataloader, val_dataloader):

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ def calculate_settings(n):`
`26`	`26`	`BLOCK_SIZE = next_power_of_2(n)`
`27`	`27`	`if BLOCK_SIZE > MAX_FUSED_SIZE:`
`28`	`28`	`raise RuntimeError(`
`29`		`- f"Cannot launch Triton kernel since n = {n} exceeds " f"the maximum CUDA blocksize = {MAX_FUSED_SIZE}."`
	`29`	`+ f"Cannot launch Triton kernel since n = {n} exceeds the maximum CUDA blocksize = {MAX_FUSED_SIZE}."`
`30`	`30`	`)`
`31`	`31`	`num_warps = 4`
`32`	`32`	`if BLOCK_SIZE >= 32768:`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ def setup(`
`103`	`103`	`raise ValueError("Quantization and mixed precision is not supported.")`
`104`	`104`	`if RequirementCache("bitsandbytes != 0.42.0"):`
`105`	`105`	`warnings.warn(`
`106`		`- "LitGPT only supports bitsandbytes v0.42.0. " "This may result in errors when using quantization."`
	`106`	`+ "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."`
`107`	`107`	`)`
`108`	`108`	`dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]`
`109`	`109`	`plugins = BitsandbytesPrecision(quantize[4:], dtype)`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ def setup(`
`105`	`105`	`raise ValueError("Quantization and mixed precision is not supported.")`
`106`	`106`	`if RequirementCache("bitsandbytes != 0.42.0"):`
`107`	`107`	`warnings.warn(`
`108`		`- "LitGPT only supports bitsandbytes v0.42.0. " "This may result in errors when using quantization."`
	`108`	`+ "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."`
`109`	`109`	`)`
`110`	`110`	`dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]`
`111`	`111`	`plugins = BitsandbytesPrecision(quantize[4:], dtype)`