lycoris-lora 3.0.0.dev16__tar.gz → 3.0.1.dev1__tar.gz

{lycoris_lora-3.0.0.dev16/lycoris_lora.egg-info → lycoris_lora-3.0.1.dev1}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: lycoris_lora
-Version: 3.0.0.dev16
+Version: 3.0.1.dev1
 Summary: Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion
 Home-page: https://github.com/KohakuBlueleaf/LyCORIS
 Author: Shih-Ying Yeh(KohakuBlueLeaf), Yu-Guan Hsieh, Zhidong Gao
 Author-email: apolloyeh0123@gmail.com
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: GPU :: NVIDIA CUDA :: 11.8
 Classifier: Environment :: GPU :: NVIDIA CUDA :: 12
 Classifier: Environment :: GPU :: NVIDIA CUDA :: 12 :: 12.1

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/README.md

@@ -1,6 +1,9 @@
-
 ![pypi](https://img.shields.io/pypi/v/lycoris-lora.svg)
 ![versions](https://img.shields.io/pypi/pyversions/lycoris-lora.svg)
+![PyPI - License](https://img.shields.io/pypi/l/lycoris-lora)
+![downloads](https://img.shields.io/pypi/dm/lycoris-lora)
+![commits](https://img.shields.io/github/commit-activity/m/KohakuBlueleaf/LyCORIS/dev)
+![Discord](https://img.shields.io/discord/1082218577395986452)
 
 # LyCORIS - Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion. (ICLR'24)
 
@@ -27,7 +30,7 @@ A simple comparison of some of these methods are provided below (to be taken wit
 |                       | Full | LoRA | LoHa | LoKr low factor | LoKr high factor$^+$ |
 | --------------------- | ---- | ---- | ---- | --------------- | ---------------------- |
 | Fidelity              | ★   | ●   | ▲   | ◉              | ▲                     |
-| Flexibility$^*$     | ★   | ●   | ◉   | ▲              | ●$^†$              |
+| Flexibility $^*$     | ★   | ●   | ◉   | ▲              | ● $^†$              |
 | Diversity             | ▲   | ◉   | ★   | ●              | ★                     |
 | Size                  | ▲   | ●   | ●   | ●              | ★                     |
 | Training Speed Linear | ★   | ●   | ●   | ★              | ★                     |
@@ -256,7 +259,7 @@ See [docs/Conversion-scripts.md](docs/Conversion-scripts.md) for more informatio
 
 For full log, please see [Change.md](Change.md)
 
-### 2024/06/xx update to 3.0.0 - Brand New Functional API, Parametrize API and Module API
+### 2024/06/29 update to 3.0.0 - Brand New Functional API, Parametrize API and Module API
 
 #### The reasons of 3.0.0
 

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris/__init__.py

@@ -1,6 +1,6 @@
 try:
     from . import kohya
-except:
+except Exception:
     pass
 from . import (
     modules,

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris/functional/general.py

@@ -76,6 +76,8 @@ def power2factorization(dimension: int, factor: int = -1) -> tuple[int, int]:
         if sum(int(i) for i in f"{dimension//m:b}") == 1:
             n = dimension // m
 
+    if n == 0:
+        return None, n
     return dimension // n, n
 
 

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris/modules/base.py

@@ -178,9 +178,9 @@ class LycorisBaseModule(ModuleCustomSD):
         # g(x) = WX + drop(ΔWX) for any algo except LoCon(lora), bypass
         # g(x) = (W + Brank_drop(A))X for LoCon(lora), rebuid
         # g(x) = (W + rank_drop(ΔW))X for any algo except LoCon(lora), rebuild
-        self.drop = nn.Identity() if dropout == 0.0 else nn.Dropout(dropout)
+        self.drop = nn.Identity() if dropout == 0 else nn.Dropout(dropout)
         self.rank_drop = (
-            nn.Identity() if rank_dropout == 0.0 else nn.Dropout(rank_dropout)
+            nn.Identity() if rank_dropout == 0 else nn.Dropout(rank_dropout)
         )
 
         self.multiplier = multiplier

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris/modules/dylora.py

@@ -114,7 +114,7 @@ class DyLoraModule(LycorisBaseModule):
         if rank is None:
             down, up, scale = self.get_random_rank_weight()
         else:
-            down, up, scale = self.get_random_rank_weight()
+            down, up, scale = self.get_weight(rank)
         w = up @ (down * (scale * multiplier))
         if device is not None:
             w = w.to(device)
@@ -132,7 +132,7 @@ class DyLoraModule(LycorisBaseModule):
         if rank is None:
             down, up, gamma = self.get_random_rank_weight()
         else:
-            down, up, gamma = self.get_random_rank_weight()
+            down, up, scale = self.get_weight(rank)
         down = down.view(self.lora_dim, -1, *self.shape[2:])
         up = up.view(-1, self.lora_dim, *(1 for _ in self.shape[2:]))
         scale = scale * gamma

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris/modules/full.py

@@ -94,6 +94,21 @@ class FullModule(LycorisBaseModule):
         else:
             self.org_bias = None
 
+    def merge_to(self, multiplier=1.0):
+        need_restore = False
+        if not hasattr(self, "_org_weight"):
+            need_restore = True
+            self.apply_to()
+        result = super().merge_to(multiplier)
+        if need_restore:
+            self.weight = nn.Parameter(torch.zeros_like(self.org_module[0].weight))
+            if self.org_module[0].bias is not None:
+                self.bias = nn.Parameter(torch.zeros_like(self.org_module[0].bias))
+            else:
+                self.bias = None
+            self.org_module[0].forward = self.org_forward
+        return result
+
     def restore(self):
         self.org_module[0].forward = self.org_forward
         self.org_module[0].weight = nn.Parameter(self._org_weight[0])

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris/modules/glora.py

@@ -76,7 +76,7 @@ class GLoRAModule(LycorisBaseModule):
             stride = org_module.stride
             padding = org_module.padding
             out_dim = org_module.out_channels
-            self.tucker = use_tucker and all(i == 1 for i in k_size)
+            use_tucker = use_tucker and all(i == 1 for i in k_size)
             self.down_op = self.op
             self.up_op = self.op
 

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris/modules/locon.py

@@ -7,7 +7,7 @@ import torch.nn.functional as F
 
 from .base import LycorisBaseModule
 from ..functional.general import rebuild_tucker
-from ..logging import logger
+from ..logging import logger, warning_once
 from ..utils.bnb import LinearNF4
 
 
@@ -79,7 +79,7 @@ class LoConModule(LycorisBaseModule):
             stride = org_module.stride
             padding = org_module.padding
             out_dim = org_module.out_channels
-            self.tucker = use_tucker and any(i != 1 for i in k_size)
+            use_tucker = use_tucker and any(i != 1 for i in k_size)
             self.down_op = self.op
             self.up_op = self.op
             if use_tucker and any(i != 1 for i in k_size):
@@ -135,7 +135,7 @@ class LoConModule(LycorisBaseModule):
 
         self.scale = alpha / r_factor
 
-        self.register_buffer("alpha", torch.tensor(alpha))  # 定数として扱える
+        self.register_buffer("alpha", torch.tensor(alpha * (lora_dim / r_factor)))
 
         if use_scalar:
             self.scalar = nn.Parameter(torch.tensor(0.0))
@@ -218,15 +218,15 @@ class LoConModule(LycorisBaseModule):
         return diff, None
 
     def get_merged_weight(self, multiplier=1, shape=None, device=None):
-        merged = (
-            self.org_module[0].weight.data
-            + self.get_diff_weight(multiplier=multiplier, shape=shape, device=device)[0]
-        )
+        diff = self.get_diff_weight(multiplier=1, shape=shape, device=device)[0]
+        weight = self.org_weight
         if self.wd:
-            merged = self.apply_weight_decompose(merged)
+            merged = self.apply_weight_decompose(weight + diff, multiplier)
+        else:
+            merged = weight + diff * multiplier
         return merged, None
 
-    def apply_weight_decompose(self, weight):
+    def apply_weight_decompose(self, weight, multiplier=1):
         weight = weight.to(self.dora_scale.dtype)
         weight_norm = (
             weight.transpose(0, 1)
@@ -236,7 +236,11 @@ class LoConModule(LycorisBaseModule):
             .transpose(0, 1)
         ) + torch.finfo(weight.dtype).eps
 
-        return weight * (self.dora_scale.to(weight.device) / weight_norm)
+        scale = self.dora_scale.to(weight.device) / weight_norm
+        if multiplier != 1:
+            scale = multiplier * (scale - 1) + 1
+
+        return weight * scale
 
     def custom_state_dict(self):
         destination = {}
@@ -289,16 +293,18 @@ class LoConModule(LycorisBaseModule):
         if self.module_dropout and self.training:
             if torch.rand(1) < self.module_dropout:
                 return self.org_forward(x)
-        scale = self.scale * self.multiplier
+        scale = self.scale
 
         dtype = self.dtype
         if not self.bypass_mode:
-            weight = (
-                self.org_module[0].weight.data.to(dtype)
-                + self.make_weight(x.device).to(dtype) * scale
-            )
+            diff_weight = self.make_weight(x.device).to(dtype) * scale
+            weight = self.org_module[0].weight.data.to(dtype)
             if self.wd:
-                weight = self.apply_weight_decompose(weight)
+                weight = self.apply_weight_decompose(
+                    weight + diff_weight, self.multiplier
+                )
+            else:
+                weight = weight + diff_weight * self.multiplier
             bias = (
                 None
                 if self.org_module[0].bias is None

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris/modules/loha.py

@@ -125,7 +125,7 @@ class LohaModule(LycorisBaseModule):
 
         self.scale = alpha / r_factor
 
-        self.register_buffer("alpha", torch.tensor(alpha))  # 定数として扱える
+        self.register_buffer("alpha", torch.tensor(alpha * (lora_dim / r_factor)))
 
         if use_scalar:
             self.scalar = nn.Parameter(torch.tensor(0.0))
@@ -220,15 +220,15 @@ class LohaModule(LycorisBaseModule):
         return diff, None
 
     def get_merged_weight(self, multiplier=1, shape=None, device=None):
-        merged = (
-            self.org_module[0].weight.data
-            + self.get_diff_weight(multiplier=multiplier, shape=shape, device=device)[0]
-        )
+        diff = self.get_diff_weight(multiplier=1, shape=shape, device=device)[0]
+        weight = self.org_weight
         if self.wd:
-            merged = self.apply_weight_decompose(merged)
+            merged = self.apply_weight_decompose(weight + diff, multiplier)
+        else:
+            merged = weight + diff * multiplier
         return merged, None
 
-    def apply_weight_decompose(self, weight):
+    def apply_weight_decompose(self, weight, multiplier=1):
         weight = weight.to(self.dora_scale.dtype)
         weight_norm = (
             weight.transpose(0, 1)
@@ -238,7 +238,11 @@ class LohaModule(LycorisBaseModule):
             .transpose(0, 1)
         ) + torch.finfo(weight.dtype).eps
 
-        return weight * (self.dora_scale / weight_norm)
+        scale = self.dora_scale.to(weight.device) / weight_norm
+        if multiplier != 1:
+            scale = multiplier * (scale - 1) + 1
+
+        return weight * scale
 
     def custom_state_dict(self):
         destination = {}
@@ -289,16 +293,17 @@ class LohaModule(LycorisBaseModule):
         if self.bypass_mode:
             return self.bypass_forward(x, scale=self.multiplier)
         else:
-            weight = (
-                self.org_module[0].weight.data.to(self.dtype)
-                + self.get_weight(self.shape) * self.scalar * self.multiplier
-            )
+            diff_weight = self.get_weight(self.shape).to(self.dtype) * self.scalar
+            weight = self.org_module[0].weight.data.to(self.dtype)
+            if self.wd:
+                weight = self.apply_weight_decompose(
+                    weight + diff_weight, self.multiplier
+                )
+            else:
+                weight = weight + diff_weight * self.multiplier
             bias = (
                 None
                 if self.org_module[0].bias is None
                 else self.org_module[0].bias.data
             )
-
-            if self.wd:
-                weight = self.apply_weight_decompose(weight)
             return self.op(x, weight, bias, **self.kw_dict)

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris/modules/lokr.py

@@ -208,7 +208,7 @@ class LokrModule(LycorisBaseModule):
 
         self.scale = alpha / r_factor
 
-        self.register_buffer("alpha", torch.tensor(alpha))  # 定数として扱える
+        self.register_buffer("alpha", torch.tensor(alpha * (lora_dim / r_factor)))
 
         if use_scalar:
             self.scalar = nn.Parameter(torch.tensor(0.0))
@@ -358,15 +358,15 @@ class LokrModule(LycorisBaseModule):
         return diff, None
 
     def get_merged_weight(self, multiplier=1, shape=None, device=None):
-        merged = (
-            self.org_module[0].weight.data
-            + self.get_diff_weight(multiplier=multiplier, shape=shape, device=device)[0]
-        )
+        diff = self.get_diff_weight(multiplier=1, shape=shape, device=device)[0]
+        weight = self.org_weight
         if self.wd:
-            merged = self.apply_weight_decompose(merged)
+            merged = self.apply_weight_decompose(weight + diff, multiplier)
+        else:
+            merged = weight + diff * multiplier
         return merged, None
 
-    def apply_weight_decompose(self, weight):
+    def apply_weight_decompose(self, weight, multiplier=1):
         weight = weight.to(self.dora_scale.dtype)
         weight_norm = (
             weight.transpose(0, 1)
@@ -376,7 +376,11 @@ class LokrModule(LycorisBaseModule):
             .transpose(0, 1)
         ) + torch.finfo(weight.dtype).eps
 
-        return weight * (self.dora_scale / weight_norm)
+        scale = self.dora_scale.to(weight.device) / weight_norm
+        if multiplier != 1:
+            scale = multiplier * (scale - 1) + 1
+
+        return weight * scale
 
     def custom_state_dict(self):
         destination = {}
@@ -506,18 +510,19 @@ class LokrModule(LycorisBaseModule):
         if self.bypass_mode:
             return self.bypass_forward(x, self.multiplier)
         else:
-            weight = (
-                self.org_module[0].weight.data.to(self.dtype)
-                + self.get_weight(self.shape) * self.scalar * self.multiplier
-            )
+            diff_weight = self.get_weight(self.shape).to(self.dtype) * self.scalar
+            weight = self.org_module[0].weight.data.to(self.dtype)
+            if self.wd:
+                weight = self.apply_weight_decompose(
+                    weight + diff_weight, self.multiplier
+                )
+            else:
+                weight = weight + diff_weight * self.multiplier
             bias = (
                 None
                 if self.org_module[0].bias is None
                 else self.org_module[0].bias.data
             )
-
-            if self.wd:
-                weight = self.apply_weight_decompose(weight)
             return self.op(x, weight, bias, **self.kw_dict)
 
 

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris/utils/bnb.py

@@ -4,7 +4,7 @@ try:
     from bitsandbytes.nn import LinearNF4, Linear8bitLt, LinearFP4
 
     SUPPORT_BNB = True
-except:
+except Exception:
     SUPPORT_BNB = False
     import torch.nn as nn
 

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris/utils/xformers_utils.py

@@ -1,13 +1,13 @@
 memory_efficient_attention = None
 try:
     import xformers
-except:
+except Exception:
     pass
 
 try:
     from xformers.ops import memory_efficient_attention
 
     XFORMERS_AVAIL = True
-except:
+except Exception:
     memory_efficient_attention = None
     XFORMERS_AVAIL = False

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1/lycoris_lora.egg-info}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: lycoris_lora
-Version: 3.0.0.dev16
+Version: 3.0.1.dev1
 Summary: Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion
 Home-page: https://github.com/KohakuBlueleaf/LyCORIS
 Author: Shih-Ying Yeh(KohakuBlueLeaf), Yu-Guan Hsieh, Zhidong Gao
 Author-email: apolloyeh0123@gmail.com
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: GPU :: NVIDIA CUDA :: 11.8
 Classifier: Environment :: GPU :: NVIDIA CUDA :: 12
 Classifier: Environment :: GPU :: NVIDIA CUDA :: 12 :: 12.1

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/lycoris_lora.egg-info/SOURCES.txt

@@ -39,5 +39,6 @@ lycoris_lora.egg-info/requires.txt
 lycoris_lora.egg-info/top_level.txt
 test/__init__.py
 test/functional.py
+test/kohya.py
 test/module.py
 test/wrapper.py

lycoris_lora-3.0.1.dev1/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup, find_packages
+
+
+setup(
+    name="lycoris_lora",
+    packages=find_packages(),
+    version="3.0.1.dev1",
+    url="https://github.com/KohakuBlueleaf/LyCORIS",
+    description="Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion",
+    author="Shih-Ying Yeh(KohakuBlueLeaf), Yu-Guan Hsieh, Zhidong Gao",
+    author_email="apolloyeh0123@gmail.com",
+    zip_safe=False,
+    install_requires=["torch", "einops", "toml", "tqdm"],
+    python_requires=">=3.10",
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Environment :: GPU :: NVIDIA CUDA :: 11.8",
+        "Environment :: GPU :: NVIDIA CUDA :: 12",
+        "Environment :: GPU :: NVIDIA CUDA :: 12 :: 12.1",
+        "Intended Audience :: Developers",
+        "Intended Audience :: End Users/Desktop",
+        "License :: OSI Approved :: Apache Software License",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Operating System :: OS Independent",
+    ],
+)

lycoris_lora-3.0.1.dev1/test/kohya.py

@@ -0,0 +1,133 @@
+import unittest
+from itertools import product
+from parameterized import parameterized
+
+import torch
+
+from lycoris.kohya import (
+    LycorisNetworkKohya,
+    create_network,
+    create_network_from_weights,
+)
+from lycoris.utils import merge, extract_diff
+
+from library.model_util import (
+    load_models_from_stable_diffusion_checkpoint as load_sd,
+    load_file,
+)
+from library.sdxl_model_util import (
+    load_models_from_sdxl_checkpoint as load_sdxl,
+)
+
+
+algos: list[str] = [
+    "lora",
+    "loha",
+    "lokr",
+    "full",
+    "diag-oft",
+    "boft",
+    "glora",
+    "ia3",
+]
+if torch.cuda.is_available():
+    device_and_dtype = [
+        (torch.device("cuda"), torch.float16),
+    ]
+else:
+    device_and_dtype = [
+        (torch.device("cpu"), torch.float32),
+    ]
+weight_decompose = [
+    False,
+    True,
+]
+use_tucker = [
+    False,
+    True,
+]
+use_scalar = [
+    False,
+    True,
+]
+
+wrapper_param_list = list(
+    product(
+        algos,
+        device_and_dtype,
+        weight_decompose,
+        use_tucker,
+        use_scalar,
+    )
+)
+extract_param_list = list(
+    product(
+        device_and_dtype,
+    )
+)
+
+device, dtype = device_and_dtype[0]
+sd_te1, sd_te2, vae, sdxl_unet, *_ = load_sdxl(
+    None, "./models/kohaku-xl-beta7.safetensors", "cpu", dtype
+)
+
+
+class LycorisKohyaWrapperTests(unittest.TestCase):
+    @parameterized.expand(wrapper_param_list)
+    def test_wrapper(self, algo, device_dtype, wd, tucker, scalar):
+        device, dtype = device_dtype
+        print(
+            f"{algo: <18}",
+            f"device={str(device): <5}",
+            f"dtype={str(dtype): <15}",
+            f"wd={str(wd): <6}",
+            f"tucker={str(tucker): <6}",
+            f"scalar={str(scalar): <6}",
+            sep="|| ",
+        )
+        network = create_network(
+            1,
+            16,
+            16,
+            vae,
+            [sd_te1, sd_te2],
+            sdxl_unet,
+            algo=algo,
+            conv_dim=16,
+            conv_alpha=16.0,
+            dropout=0.0,
+            rank_dropout=0.0,
+            weight_decompose=wd,
+            use_tucker=tucker,
+            use_scalar=scalar,
+            train_norm=True,
+        )
+        network.apply_to([sd_te1, sd_te2], sdxl_unet, True, True)
+        network.restore()
+        create_network_from_weights(
+            1, "", vae, [sd_te1, sd_te2], sdxl_unet, weights_sd=network.state_dict()
+        )
+        torch.cuda.empty_cache()
+
+    @parameterized.expand(extract_param_list)
+    def test_extract(self, device_dtype):
+        device, dtype = device_dtype
+        print(
+            "Extract",
+            f"device={str(device): <5}",
+            f"dtype={str(dtype): <15}",
+            sep="|| ",
+        )
+        extract_diff(
+            [sd_te1, sd_te2],
+            [sd_te1, sd_te2],
+            sdxl_unet,
+            sdxl_unet,
+            mode="fixed",
+            linear_mode_param=4,
+            conv_mode_param=4,
+            extract_device=device,
+            use_bias=True,
+            sparsity=0.98,
+            small_conv=True,
+        )

{lycoris_lora-3.0.0.dev16 → lycoris_lora-3.0.1.dev1}/test/module.py

@@ -102,6 +102,9 @@ class LycorisModuleTests(unittest.TestCase):
         net.restore()
         net.merge_to()
 
+        # attr access test
+        net.org_weight
+
     @parameterized.expand(patch_forward_param_list)
     def test_lycoris_modules_bypass_mode(
         self, module, base, device_dtype, wd, tucker, scalar

lycoris_lora-3.0.0.dev16/setup.py

@@ -1,29 +0,0 @@
-from setuptools import setup, find_packages
-
-
-setup(
-    name="lycoris_lora",
-    packages=find_packages(),
-    version="3.0.0.dev16",
-    url="https://github.com/KohakuBlueleaf/LyCORIS",
-    description="Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion",
-    author="Shih-Ying Yeh(KohakuBlueLeaf), Yu-Guan Hsieh, Zhidong Gao",
-    author_email="apolloyeh0123@gmail.com",
-    zip_safe=False,
-    install_requires=["torch", "einops", "toml", "tqdm"],
-    python_requires=">=3.10",
-    classifiers=[
-        'Development Status :: 4 - Beta',
-        'Environment :: GPU :: NVIDIA CUDA :: 11.8',
-        'Environment :: GPU :: NVIDIA CUDA :: 12',
-        'Environment :: GPU :: NVIDIA CUDA :: 12 :: 12.1',
-        'Intended Audience :: Developers',
-        'Intended Audience :: End Users/Desktop',
-        'License :: OSI Approved :: Apache Software License',
-        'Programming Language :: Python',
-        'Programming Language :: Python :: 3.10',
-        'Programming Language :: Python :: 3.11',
-        'Programming Language :: Python :: 3.12',
-        'Operating System :: OS Independent',
-    ],
-)