ai-simple-engine-runtime-diffusers 0.0.1__py3-none-any.whl

ai_simple_engine_runtime_diffusers/__init__.py

@@ -0,0 +1,4 @@
+"""
+The plugin to add the Huggingface platform as
+a backend to be able to download the models.
+"""

ai_simple_engine_runtime_diffusers/models/executor/diffusers_latent_diffusion_model_executor.py

@@ -0,0 +1,123 @@
+from ai_simple_engine_runtime_diffusers.models.scheduler.diffusers_scheduler import DiffusersScheduler
+from ai_simple_engine_diffusion.model.executor.abstract.latent_diffusion_model_executor_abstract import LatentDiffusionModelExecutorAbstract
+from ai_simple_engine.execution.execution_context import ExecutionContext
+from ai_simple_engine_runtime_diffusers.models.executor.prompt_embeddings.prompt_embeddings import PromptEmbeddings
+from ai_simple_engine_runtime_diffusers.models.scheduler.registry.diffusers_scheduler_registry import DiffusersSchedulerRegistry
+from ai_simple_engine.models.loaded_model import LoadedModel
+
+import torch
+
+
+class DiffusersLatentDiffusionModelExecutor (
+    LatentDiffusionModelExecutorAbstract
+):
+    """
+    Latent diffusion executor based on the Hugging Face
+    Diffusers library.
+
+    Implements the model-specific operations required by
+    `LatentDiffusionModelExecutor` using Diffusers
+    components such as the tokenizer, text encoder,
+    UNet/DiT, VAE and schedulers.
+    """
+    
+    def create_scheduler(
+        self,
+        context: ExecutionContext,
+        model: LoadedModel,
+    ):
+        scheduler_registry = context.services.resolve(DiffusersSchedulerRegistry)
+
+        scheduler_class = scheduler_registry.resolve(model.info.scheduler.name)
+
+        scheduler = scheduler_class.from_config(
+            model.instance.scheduler_config,
+            **model.info.scheduler.kwargs
+        )
+
+        return DiffusersScheduler(scheduler)
+        
+
+    async def predict_noise(
+        self,
+        *,
+        model: LoadedModel,
+        latents,
+        embeddings: PromptEmbeddings,
+        timestep,
+        guidance_scale
+    ):
+        runtime_model = model.instance
+        unet = runtime_model.unet
+        latent_input = torch.cat([latents, latents])
+
+        encoder_hidden_states = torch.cat([
+            embeddings.negative,
+            embeddings.positive
+        ])
+
+        noise = unet(
+            latent_input,
+            timestep,
+            encoder_hidden_states = encoder_hidden_states
+        ).sample
+
+        noise_uncond, noise_text = noise.chunk(2)
+
+        return noise_uncond + guidance_scale * (
+            noise_text - noise_uncond
+        )
+    
+    # Specific methods below
+    async def encode_prompt(
+        self,
+        *,
+        model: LoadedModel,
+        prompt: str,
+        negative_prompt: str
+    ) -> PromptEmbeddings:
+        runtime_model = model.instance
+
+        tokenizer = runtime_model.tokenizer
+        text_encoder = runtime_model.text_encoder
+
+        positive = tokenizer(
+            prompt,
+            padding = 'max_length',
+            truncation = True,
+            max_length = tokenizer.model_max_length,
+            return_tensors = 'pt'
+        )
+
+        negative = tokenizer(
+            negative_prompt,
+            padding = 'max_length',
+            truncation = True,
+            max_length = tokenizer.model_max_length,
+            return_tensors = 'pt'
+        )
+
+        device = next(text_encoder.parameters()).device
+        positive = text_encoder(positive.input_ids.to(device))[0]
+        negative = text_encoder(negative.input_ids.to(device))[0]
+
+        return PromptEmbeddings(
+            positive = positive,
+            negative = negative
+        )
+    
+    async def decode_latents(
+        self,
+        *,
+        model,
+        latents
+    ):
+        runtime_model = model.model
+
+        vae = runtime_model.vae
+
+        latents = latents / vae.config.scaling_factor
+
+        image = vae.decode(latents).sample
+
+        return image

ai_simple_engine_runtime_diffusers/models/executor/noise/__init__.py

@@ -0,0 +1,4 @@
+"""
+TODO: I don't know if this module should be
+here or not...
+"""

ai_simple_engine_runtime_diffusers/models/executor/noise/pytorch_noise_generator.py

@@ -0,0 +1,25 @@
+from ai_simple_engine_diffusion.noise.noise_generator_abstract import NoiseGenerator
+
+import torch
+
+
+class TorchNoiseGenerator(
+    NoiseGenerator
+):
+
+    def generate(
+        self,
+        *,
+        shape,
+        device,
+        dtype,
+        seed: int
+    ):
+        generator = torch.Generator(device = device).manual_seed(seed)
+
+        return torch.randn(
+            shape,
+            generator = generator,
+            device = device,
+            dtype = dtype,
+        )

ai_simple_engine_runtime_diffusers/models/executor/prompt_embeddings/prompt_embeddings.py

@@ -0,0 +1,18 @@
+"""
+TODO: I don't like this module here
+"""
+from dataclasses import dataclass
+
+
+@dataclass(frozen = True)
+class PromptEmbeddings:
+    """
+    *Dataclass*
+
+    Class to include the `positive` and the
+    `negative` prompt embeddings at the same
+    time.
+    """
+
+    positive: object
+    negative: object

ai_simple_engine_runtime_diffusers/models/executor/text_encoder_model_executor_abstract.py

@@ -0,0 +1,32 @@
+"""
+TODO: This is unnecessary, but maybe we want
+each ModelExecutor being capable of performing
+single operations. Check and remove if not.
+"""
+from ai_simple_engine.models.executor.abstract import ModelExecutor
+from ai_simple_engine.models.loaded_model import LoadedModel
+from ai_simple_engine_diffusion.types.data_type import Embeddings
+from abc import ABC, abstractmethod
+
+
+# This will be to perform 'EncodePrompt()'
+class TextEncoderModelExecutorAbstract(
+    ModelExecutor,
+    ABC
+):
+    """
+    *Abstract class*
+
+    To convert text into embeddings
+    """
+
+    @abstractmethod
+    async def encode(
+        self,
+        model: LoadedModel,
+        prompt: str
+    ) -> Embeddings:
+        """
+        Encode the given prompt into embeddings.
+        """
+        ...

ai_simple_engine_runtime_diffusers/models/executor/unet_model_executor_abstract.py

@@ -0,0 +1,36 @@
+"""
+TODO: This is unnecessary, but maybe we want
+each ModelExecutor being capable of performing
+single operations. Check and remove if not.
+"""
+from ai_simple_engine_diffusion.types.latents import Latents
+from ai_simple_engine_diffusion.types.noise_prediction import NoisePrediction
+from ai_simple_engine_diffusion.types.embeddings import Embeddings
+from ai_simple_engine.models.executor.abstract import ModelExecutor
+from ai_simple_engine.models.loaded_model import LoadedModel
+from abc import ABC, abstractmethod
+
+
+class UNetModelExecutorAbstract(
+    ModelExecutor,
+    ABC
+):
+    """
+    *Abstract class*
+
+    To predict the noise.
+    """
+
+    @abstractmethod
+    async def predict_noise(
+        self,
+        model: LoadedModel,
+        latents: Latents,
+        embeddings: Embeddings,
+        timestep: int
+    ) -> NoisePrediction:
+        """
+        Predict the noise residual for the given
+        latents at the specified timestep.
+        """
+        ...

ai_simple_engine_runtime_diffusers/models/executor/vae_model_executor_abstract.py

@@ -0,0 +1,44 @@
+"""
+TODO: This is unnecessary, but maybe we want
+each ModelExecutor being capable of performing
+single operations. Check and remove if not.
+"""
+from ai_simple_engine_diffusion.types.latents import Latents
+from ai_simple_engine.models.executor.abstract import ModelExecutor
+from ai_simple_engine.models.loaded_model import LoadedModel
+from ai_simple_engine.types.image import Image
+from abc import ABC, abstractmethod
+
+
+class VAEModelExecutorAbstract(
+    ModelExecutor,
+    ABC
+):
+    """
+    *Abstract class*
+
+    To transform images into latents and
+    latents into images.
+    """
+
+    @abstractmethod
+    async def encode(
+        self,
+        model: LoadedModel,
+        image: Image
+    ) -> Latents:
+        """
+        Encode an image into latent space.
+        """
+        ...
+
+    @abstractmethod
+    async def decode(
+        self,
+        model: LoadedModel,
+        latents: Latents
+    ) -> Image:
+        """
+        Decode latent representations into an image.
+        """
+        ...

ai_simple_engine_runtime_diffusers/models/loader/latent_diffusion_model_loader.py

@@ -0,0 +1,90 @@
+from ai_simple_engine_runtime_diffusers.models.runtime.diffusers_latent_diffusion_model import DiffusersLatentDiffusionModel
+from ai_simple_engine_runtime_diffusers.models.runtime.utils import get_torch_dtype_for
+from ai_simple_engine_diffusion.model.info.diffusion_model_info import DiffusionModelInfo
+from ai_simple_engine_diffusion.scheduler.spec.base import SchedulerSpec
+from ai_simple_engine.device.base import Device
+from ai_simple_engine.models.loaders.abstract import ModelLoader
+from ai_simple_engine.models.installed_model import InstalledModel
+from ai_simple_engine.models.loaded_model import LoadedModel
+from transformers import CLIPTokenizer, CLIPTextModel
+from diffusers import UNet2DConditionModel, AutoencoderKL
+
+import torch
+
+
+class LatentDiffusionModelLoader(
+    ModelLoader
+):
+
+    async def load(
+        self,
+        installed_model: InstalledModel,
+        device: Device
+    ) -> LoadedModel:
+        path = str(installed_model.path)
+
+        tokenizer = CLIPTokenizer.from_pretrained(
+            path,
+            subfolder = 'tokenizer',
+            torch_dtype = get_torch_dtype_for(device)
+        ).to(str(device))
+
+        text_encoder = CLIPTextModel.from_pretrained(
+            path,
+            subfolder = 'text_encoder',
+            torch_dtype = get_torch_dtype_for(device)
+        ).to(str(device))
+
+        unet = UNet2DConditionModel.from_pretrained(
+            path,
+            subfolder = 'unet',
+            torch_dtype = get_torch_dtype_for(device)
+        ).to(str(device))
+
+        vae = AutoencoderKL.from_pretrained(
+            path,
+            subfolder = 'vae',
+            torch_dtype = get_torch_dtype_for(device)
+        ).to(str(device))
+
+        scheduler_config = AutoencoderKL.load_config(
+            path,
+            subfolder = 'scheduler',
+            torch_dtype = get_torch_dtype_for(device)
+        ).to(str(device))
+
+        runtime_model = DiffusersLatentDiffusionModel(
+            tokenizer = tokenizer,
+            text_encoder = text_encoder,
+            unet = unet,
+            vae = vae,
+            scheduler_config = scheduler_config
+        )
+
+        info = DiffusionModelInfo(
+            latent_channels = unet.config.in_channels,
+            vae_scale_factor = 2 ** (len(vae.config.block_out_channels) - 1),
+            # TODO: Make dynamic depending on the 'installed_model'
+            scheduler = self._default_scheduler(installed_model)
+        )
+
+        return LoadedModel(
+            installed_model = installed_model,
+            instance = runtime_model,
+            info = info
+        )
+    
+    def _default_scheduler(
+        self,
+        installed_model: InstalledModel
+    ) -> SchedulerSpec:
+        """
+        *For internal use only*
+
+        Get the scheduler by default for the
+        `installed_model` provided.
+        """
+        # TODO: Make dynamic based on the 'installed_model'
+        return SchedulerSpec(
+            identifier = 'euler'
+        )

ai_simple_engine_runtime_diffusers/models/runtime/diffusers_latent_diffusion_model.py

@@ -0,0 +1,19 @@
+from transformers import CLIPTokenizer, CLIPTextModel
+from diffusers import UNet2DConditionModel, AutoencoderKL
+from dataclasses import dataclass
+
+
+@dataclass(frozen = True)
+class DiffusersLatentDiffusionModel:
+    """
+    Runtime representation of a Latent Diffusion
+    model loaded through Diffusers.
+    """
+
+    tokenizer: CLIPTokenizer
+    text_encoder: CLIPTextModel
+    unet: UNet2DConditionModel
+    vae: AutoencoderKL
+    scheduler_config: dict
+
+    

ai_simple_engine_runtime_diffusers/models/runtime/utils.py

@@ -0,0 +1,19 @@
+from ai_simple_engine.device.base import Device
+
+import torch
+
+
+def get_torch_dtype_for(
+    device: Device
+):
+    """
+    Get the `torch` `dtype` for the `device`
+    provided.
+    """
+    if device.type == 'cuda':
+        return torch.float16
+
+    if device.type == 'mps':
+        return torch.float16
+
+    return torch.float32

ai_simple_engine_runtime_diffusers/models/scheduler/diffusers_scheduler.py

@@ -0,0 +1,47 @@
+from ai_simple_engine_diffusion.scheduler.abstract import Scheduler
+
+
+class DiffusersScheduler(
+    Scheduler
+):
+
+    def __init__(
+        self,
+        scheduler
+    ):
+        self._scheduler = scheduler
+
+    @property
+    def timesteps(
+        self
+    ):
+        return self._scheduler.timesteps
+
+    def set_timesteps(
+        self,
+        steps: int
+    ):
+        self._scheduler.set_timesteps(steps)
+
+    def scale_model_input(
+        self,
+        latents,
+        timestep
+    ):
+        return self._scheduler.scale_model_input(
+            latents,
+            timestep
+        )
+    
+    def step(
+        self,
+        *,
+        model_output,
+        timestep,
+        sample
+    ):
+        return self._scheduler.step(
+            model_output = model_output,
+            timestep = timestep,
+            sample = sample
+        )

ai_simple_engine_runtime_diffusers/models/scheduler/registry/diffusers_scheduler_registry.py

@@ -0,0 +1,22 @@
+from ai_simple_engine.resolver_registry import ResolverRegistry
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+
+
+class DiffusersSchedulerRegistry(
+    ResolverRegistry[
+        str,
+        type[SchedulerMixin]
+    ]
+):
+    """
+    Class that will register the different
+    Scheduler classes that we have available
+    so we can obtain them using their
+    identifier.
+    """
+    
+    def key_for(
+        self,
+        identifier: str
+    ) -> str:
+        return identifier

ai_simple_engine_runtime_diffusers/models/scheduler/utils.py

@@ -0,0 +1,44 @@
+"""
+TODO: Maybe rename and move this module.
+"""
+from diffusers.schedulers import (
+    DDIMScheduler,
+    EulerDiscreteScheduler,
+    EulerAncestralDiscreteScheduler,
+    DPMSolverMultistepScheduler,
+    FlowMatchEulerDiscreteScheduler
+)
+
+SCHEDULERS = {
+    'ddim': DDIMScheduler,
+    'euler': EulerDiscreteScheduler,
+    'euler_a': EulerAncestralDiscreteScheduler,
+    'dpmpp_2m': DPMSolverMultistepScheduler,
+    'flow_match_euler': FlowMatchEulerDiscreteScheduler
+}
+"""
+The list including all the schedulers we are
+accepting.
+"""
+
+
+def get_scheduler_class(
+    scheduler: str,
+    model: LoadedModel
+) -> Union[SchedulerMixin, None]:
+    scheduler_class = SCHEDULERS.get(scheduler, None)
+
+    if scheduler_class is None:
+        raise Exception(f'The scheduler "{scheduler}" is not accepted by our system.')
+    
+    return scheduler_class
+
+    scheduler_cls = registry.resolve(model.info.scheduler.identifier)
+
+    scheduler = scheduler_cls.from_config(...)
+
+    return scheduler
+
+    return scheduler_cls.from_config(
+        model.model.scheduler.config
+    )

ai_simple_engine_runtime_diffusers/plugin.py

@@ -0,0 +1,69 @@
+from ai_simple_engine_runtime_diffusers.models.loader.latent_diffusion_model_loader import LatentDiffusionModelLoader
+from ai_simple_engine_runtime_diffusers.models.scheduler.utils import SCHEDULERS
+from ai_simple_engine_runtime_diffusers.models.scheduler.registry.diffusers_scheduler_registry import DiffusersSchedulerRegistry
+from ai_simple_engine.engine_builder import EngineBuilder
+from ai_simple_engine.plugins.plugin import Plugin
+
+
+class DiffusersRuntimeMusicgenPlugin(
+    Plugin
+):
+    """
+    The plugin to add the diffusers' models
+    functionality.
+
+    This plugin includes:
+    """
+
+    def register(
+        self,
+        builder: EngineBuilder
+    ):
+        
+
+        (
+            builder.add_model_loader(LatentDiffusionModelLoader)
+        )
+
+        # TODO: Register the SchedulerRegistry
+        """
+        Dinamycally register all the scheduler classes
+        incldued in the 'SCHEDULERS' dict. The executor
+        will resolve the instance when trying to
+        execute:
+
+        scheduler_cls = registry.resolve(
+            scheduler_spec.identifier
+        )
+        """
+        scheduler_registry = builder.get_or_add_service(DiffusersSchedulerRegistry)
+
+        for identifier, cls in SCHEDULERS.items():
+            scheduler_registry.register(
+                identifier,
+                cls
+            )
+        
+        # scheduler_registry.register(
+        #     'euler',
+        #     EulerDiscreteScheduler
+        # )
+
+        # TODO: This below was the 'musicgen'
+        # (
+        #     builder
+        #     .add_model_loader(MusicgenModelLoader())
+        # )
+
+        # """
+        # We obtain the registry that handles the
+        # model executors by the model's family,
+        # and we register our specific model
+        # executor that uses transformers.
+        # """
+        # registry = builder.get_or_add_service(FamilyModelExecutorRegistry)
+
+        # registry.register(
+        #     MUSICGEN_MODEL_FAMILY,
+        #     TransformersMusicgenModelExecutor()
+        # )

ai_simple_engine_runtime_diffusers-0.0.1.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: ai-simple-engine-runtime-diffusers
+Version: 0.0.1
+Summary: AI Simple Engine Runtime Diffusers Module
+License-File: LICENSE
+Author: danialcala94
+Author-email: danielalcalavalera@gmail.com
+Requires-Python: >=3.10,<3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: ai-simple-engine (>=0.2.6,<1.0.0)
+Requires-Dist: ai-simple-engine-common (>=0.0.3,<1.0.0)
+Requires-Dist: ai-simple-engine-diffusion (>=0.0.2,<1.0.0)
+Requires-Dist: diffusers (>=0.38.0,<1.0.0)
+Requires-Dist: transformers (>=0.0.1,<1.0.0)
+Description-Content-Type: text/markdown
+
+# AI Simple Engine Runtime Diffusers Module
+
+The module that implements the Runtime Diffusers module for the AI Simple Engine `ai-simple-engine`.

ai_simple_engine_runtime_diffusers-0.0.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+ai_simple_engine_runtime_diffusers/__init__.py,sha256=oeCwDniRRNaeu1i8oSoIGl24B_le57R-tjJfbQIcaTA,101
+ai_simple_engine_runtime_diffusers/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_simple_engine_runtime_diffusers/models/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_simple_engine_runtime_diffusers/models/executor/diffusers_latent_diffusion_model_executor.py,sha256=-kVvNpBZLbcWuHiXo6cj3-Y6mVXCn9YIN9S_7opKbj0,3701
+ai_simple_engine_runtime_diffusers/models/executor/noise/__init__.py,sha256=gtBak1TwMesgIsuc56HdYmCwrTjdysO68FO6XzAs-ME,69
+ai_simple_engine_runtime_diffusers/models/executor/noise/pytorch_noise_generator.py,sha256=kFL42BiG2odZp7hAA-7FZakihakOzc8BpYorysDvWx0,508
+ai_simple_engine_runtime_diffusers/models/executor/prompt_embeddings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_simple_engine_runtime_diffusers/models/executor/prompt_embeddings/prompt_embeddings.py,sha256=Y-Krd8UkaaZofSTZoY3Iq1lYetNBBfa_x8ivkplrpBA,321
+ai_simple_engine_runtime_diffusers/models/executor/text_encoder_model_executor_abstract.py,sha256=DdGE73KVvPZOjD1ulk3ffBC3RjAx4MIf9vcsyatgUyE,805
+ai_simple_engine_runtime_diffusers/models/executor/unet_model_executor_abstract.py,sha256=xj5Fw8J1jAwJZRoE5dEnH4Ewf92jIyEh6BJEOHOY1n0,1004
+ai_simple_engine_runtime_diffusers/models/executor/vae_model_executor_abstract.py,sha256=t3j4jYHKbo7bSjMhLLOJYsY2IZm7uQGXXK-c7QDCTv8,1045
+ai_simple_engine_runtime_diffusers/models/loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_simple_engine_runtime_diffusers/models/loader/latent_diffusion_model_loader.py,sha256=fROYlfzuJCqmneCm7xr0OY2PRtKjVeL5JCVi1c-SWP0,3057
+ai_simple_engine_runtime_diffusers/models/runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_simple_engine_runtime_diffusers/models/runtime/diffusers_latent_diffusion_model.py,sha256=UTgR2mWW3rDtJXyRATpR_lfcWS6wMugeKHlvKneXTbw,478
+ai_simple_engine_runtime_diffusers/models/runtime/utils.py,sha256=niSrKW6RdZwtRPQVEFCArTyYdGgWWk-rlFSd2ledSPo,347
+ai_simple_engine_runtime_diffusers/models/scheduler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_simple_engine_runtime_diffusers/models/scheduler/diffusers_scheduler.py,sha256=TiirOtBVX9Op8VeYEjmh3F-rxCiJoEkM6ezyKFjQ_74,896
+ai_simple_engine_runtime_diffusers/models/scheduler/registry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_simple_engine_runtime_diffusers/models/scheduler/registry/diffusers_scheduler_registry.py,sha256=i9nAd_T30oFFT65awnIw_Z6cDtctmN1NWxkQArXDugY,516
+ai_simple_engine_runtime_diffusers/models/scheduler/utils.py,sha256=VSVeypJkrwaCTRZyYrmscE8g9_pufQ-AlZAhUD_3OKE,1111
+ai_simple_engine_runtime_diffusers/plugin.py,sha256=rPl2BEW9ow6R0KouaFvvBpetG5Opz92E-Rq-6xH5iLc,2101
+ai_simple_engine_runtime_diffusers-0.0.1.dist-info/licenses/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+ai_simple_engine_runtime_diffusers-0.0.1.dist-info/METADATA,sha256=p_wUk1JdE8bWcJGNq3m2tDWCbvaN_N2IptU7HbU3vX8,834
+ai_simple_engine_runtime_diffusers-0.0.1.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+ai_simple_engine_runtime_diffusers-0.0.1.dist-info/RECORD,,

ai_simple_engine_runtime_diffusers-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ai_simple_engine_runtime_diffusers-0.0.1.dist-info/licenses/LICENSE

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