flamo 0.1.4__tar.gz → 0.1.5__tar.gz

{flamo-0.1.4 → flamo-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamo
-Version: 0.1.4
+Version: 0.1.5
 Summary: An Open-Source Library for Frequency-Domain Differentiable Audio Processing
 Project-URL: Homepage, https://github.com/gdalsanto/flamo
 Project-URL: Issues, https://github.com/gdalsanto/flamo/issues
@@ -38,6 +38,7 @@ Requires-Dist: numpy
 Requires-Dist: pydantic
 Requires-Dist: pyfar
 Requires-Dist: pysoundfile
+Requires-Dist: pyyaml
 Requires-Dist: scipy
 Requires-Dist: torch
 Requires-Dist: torchaudio

{flamo-0.1.4 → flamo-0.1.5}/examples/e8_colorless_fdn.py

@@ -26,8 +26,8 @@ def example_fdn(args):
 
     # FDN parameters
     N = 6  # number of delays
-    alias_decay_db = 0  # alias decay in dB
-    delay_lengths = torch.tensor([997, 1153, 1327, 1559, 1801, 2099])
+    alias_decay_db = 30  # alias decay in dB
+    delay_lengths = torch.tensor([887, 911, 941, 1699, 1951, 2053])
 
     ## ---------------- CONSTRUCT FDN ---------------- ##
 
@@ -35,19 +35,17 @@ def example_fdn(args):
     input_gain = dsp.Gain(
         size=(N, 1),
         nfft=args.nfft,
-        requires_grad=False,
+        requires_grad=True,
         alias_decay_db=alias_decay_db,
         device=args.device,
     )
-    input_gain.assign_value(torch.ones((N, 1), device=args.device) / torch.tensor(N))
     output_gain = dsp.Gain(
         size=(1, N),
         nfft=args.nfft,
-        requires_grad=False,
+        requires_grad=True,
         alias_decay_db=alias_decay_db,
         device=args.device,
     )
-    output_gain.assign_value(torch.ones((1, N), device=args.device) )
     # Feedback loop with delays
     delays = dsp.parallelDelay(
         size=(N,),
@@ -60,7 +58,7 @@ def example_fdn(args):
     )
     delays.assign_value(delays.sample2s(delay_lengths))
     # Feedback path with orthogonal matrix
-    mixing_matrix = dsp.Matrix(
+    feedback = dsp.Matrix(
         size=(N, N),
         nfft=args.nfft,
         matrix_type="orthogonal",
@@ -68,16 +66,6 @@ def example_fdn(args):
         alias_decay_db=alias_decay_db,
         device=args.device,
     )
-    attenuation = dsp.parallelGain(
-        size=(N,),
-        nfft=args.nfft,
-        requires_grad=False,
-        alias_decay_db=alias_decay_db,
-        device=args.device,
-        )
-    attenuation.map = map_gamma(delay_lengths)
-    gamma = 6
-    attenuation.assign_value(gamma * torch.ones((N,), device=args.device,))
 
     # # Feedback path with scattering matrix
     # m_L =  torch.randint(low=1, high=int(torch.floor(min(delay_lengths)/2)), size=[N])
@@ -93,14 +81,6 @@ def example_fdn(args):
     #     requires_grad=True,
     #     device=args.device,
     # )
-    feedback = system.Series(
-        OrderedDict(
-            {
-                "attenuation": attenuation,
-                "mixing_matrix": mixing_matrix,
-            }
-        )
-    )
 
     # Recursion
     feedback_loop = system.Recursion(fF=delays, fB=feedback)
@@ -118,42 +98,9 @@ def example_fdn(args):
 
     # Create the model with Shell
     input_layer = dsp.FFT(args.nfft)
-    output_layer = dsp.iFFT(args.nfft)
+    output_layer = dsp.Transform(transform=lambda x: torch.abs(x))
     model = system.Shell(core=FDN, input_layer=input_layer, output_layer=output_layer)
 
-    ir_init = model.get_time_response(identity=False, fs=args.samplerate)
-
-    time_axis = torch.arange(0, args.nfft) / args.samplerate
-
-    out = torch.flip(ir_init, dims=[1])
-    out = torch.cumsum(out**2, dim=1)
-    out = torch.flip(out, dims=[1])
-
-    # Normalize to 1
-    norm_vals = torch.max(out, dim=1, keepdim=True)[0]  # per channel
-
-
-    edc = out / norm_vals
-    
-    core = model.get_core()
-
-    # generate a decaying sinusoid
-    sine = torch.sin(
-        2 * torch.pi * 1000 * time_axis
-    ) * torch.exp(-time_axis / 0.01)  # 1000 Hz, decay time of 0.1 seconds
-    sine = sine.unsqueeze(0).unsqueeze(-1)  # add batch and channel dimensions
- 
-    out = torch.flip(model(sine), dims=[1])
-    out = torch.cumsum(out**2, dim=1)
-    out = torch.flip(out, dims=[1])
-
-    # Normalize to 1
-    norm_vals = torch.max(out, dim=1, keepdim=True)[0]  # per channel
-
-
-    edc_sine = out / norm_vals
-    
-
     # Get initial impulse response
     with torch.no_grad():
         ir_init = model.get_time_response(identity=False, fs=args.samplerate).squeeze()
@@ -218,7 +165,7 @@ def save_fdn_params(net, filename="parameters"):
 
     core = net.get_core()
     param = {}
-    param["A"] = core.feedback_loop.feedback.mixing_matrix.param.squeeze().detach().cpu().numpy()
+    param["A"] = core.feedback_loop.feedback.param.squeeze().detach().cpu().numpy()
     param["B"] = core.input_gain.param.squeeze().detach().cpu().numpy()
     param["C"] = core.output_gain.param.squeeze().detach().cpu().numpy()
     param["m"] = (
@@ -236,20 +183,6 @@ def save_fdn_params(net, filename="parameters"):
     return param
 
 
-class map_gamma(torch.nn.Module):
-
-    def __init__(self, delays):
-        super().__init__()
-        self.delays = delays.double()
-        self.g_min = torch.tensor(0.99, dtype=torch.double, device=delays.device)
-        self.g_max = torch.tensor(1, dtype=torch.double, device=delays.device)
-
-    def forward(self, x):
-        return (
-            ((1 / (1 + torch.exp(-x[0]))) * (self.g_max - self.g_min) + self.g_min)
-            ** self.delays
-        ).type_as(x)
-
 if __name__ == "__main__":
 
     parser = argparse.ArgumentParser()

{flamo-0.1.4 → flamo-0.1.5}/examples/e8_fdn.py

@@ -490,8 +490,8 @@ if __name__ == "__main__":
 
     parser = argparse.ArgumentParser()
 
-    parser.add_argument("--nfft", type=int, default=44100*2, help="FFT size")
-    parser.add_argument("--samplerate", type=int, default=44100, help="sampling rate")
+    parser.add_argument("--nfft", type=int, default=96000, help="FFT size")
+    parser.add_argument("--samplerate", type=int, default=48000, help="sampling rate")
     parser.add_argument("--num", type=int, default=100, help="dataset size")
     parser.add_argument(
         "--device", type=str, default="cuda", help="device to use for computation"
@@ -541,6 +541,6 @@ if __name__ == "__main__":
             )
         )
 
-    example_fdn(args)
+    # example_fdn(args)
     # example_fdn_accurate_geq(args)
-    # example_fdn_direct(args)
+    example_fdn_direct(args)

{flamo-0.1.4 → flamo-0.1.5}/examples/e9_loss_profile.py

@@ -6,7 +6,7 @@ import argparse
 import yaml
 from flamo.auxiliary.reverb import HomogeneousFDN, map_gamma, inverse_map_gamma
 from flamo.auxiliary.config.config import HomogeneousFDNConfig
-from flamo.optimize.loss import mse_loss
+from flamo.optimize.loss import mse_loss, mel_mss_loss
 from flamo.optimize.surface import LossProfile, LossConfig, ParameterConfig, LossSurface
 from flamo.functional import signal_gallery, get_magnitude
 
@@ -59,7 +59,7 @@ def example_loss_profile(args):
 
     loss_profile = LossProfile(FDN.model, loss_config)
     loss = loss_profile.compute_loss(input_signal, target_signal)
-    loss_profile.plot_loss(loss, criterion_name=["MSE"])
+    loss_profile.plot_loss(loss)
 
 
 def example_loss_surface(args):
@@ -103,7 +103,7 @@ def example_loss_surface(args):
 
     # define config structures
     loss_config = LossConfig(
-        criteria=[mse_loss(), torch.nn.L1Loss()],
+        criteria=[mse_loss(), mel_mss_loss()],
         param_config=[attenuation_config, input_gain_config],
         # perturb_param=None,#"output_gain",
         perturb_map=lambda x: x,
@@ -124,7 +124,7 @@ def example_loss_surface(args):
 
     loss_profile = LossSurface(FDN.model, loss_config)
     loss = loss_profile.compute_loss(input_signal, target_signal)
-    loss_profile.plot_loss(loss, criterion_name=["MSE", "MAE"])
+    loss_profile.plot_loss(loss)
 
 if __name__ == "__main__":
 

{flamo-0.1.4 → flamo-0.1.5}/flamo/auxiliary/config/config.py

@@ -33,7 +33,8 @@ class HomogeneousFDNConfig(BaseModel):
     delays_grad: bool = False
     mixing_matrix_grad: bool = True
     attenuation_grad: bool = True
-
+    is_delay_int: bool = True
+    
     def __init__(self, **data):
         super().__init__(**data)
         if self.delays is None:

{flamo-0.1.4 → flamo-0.1.5}/flamo/auxiliary/eq.py

@@ -86,7 +86,8 @@ def geq(
 
     for band in range(num_bands):
         if band == 0:
-            b = torch.tensor([db2mag(gain_db[band]), 0, 0], device=device)
+            b = torch.zeros(3, device=device)
+            b[0] = db2mag(gain_db[band])
             a = torch.tensor([1, 0, 0], device=device)
         elif band == 1:
             b, a = shelving_filter(

{flamo-0.1.4 → flamo-0.1.5}/flamo/auxiliary/reverb.py

@@ -129,7 +129,7 @@ class HomogeneousFDN:
             size=(self.N,),
             max_len=delay_lines.max(),
             nfft=self.config_dict.nfft,
-            isint=True,
+            isint=self.config_dict.is_delay_int,
             requires_grad=self.config_dict.delays_grad,
             alias_decay_db=self.config_dict.alias_decay_db,
             device=self.config_dict.device,

{flamo-0.1.4 → flamo-0.1.5}/flamo/optimize/loss.py

@@ -77,6 +77,7 @@ class mse_loss(nn.Module):
         self.nfft = nfft
         self.device = device
         self.mse_loss = nn.MSELoss()
+        self.name = "MSE"
 
     def forward(self, y_pred, y_true):
         """

{flamo-0.1.4 → flamo-0.1.5}/flamo/processor/dsp.py

@@ -2743,7 +2743,7 @@ class Delay(DSP):
         """
         m = self.get_delays()
         if self.isint:
-            self.freq_response = lambda param: (self.gamma ** m(param)) * torch.exp(
+            self.freq_response = lambda param: (self.gamma ** m(param).round()) * torch.exp(
                 -1j
                 * torch.einsum(
                     "fo, omn -> fmn",
@@ -2880,14 +2880,24 @@ class parallelDelay(Delay):
         Computes the frequency response of the delay module.
         """
         m = self.get_delays()
-        self.freq_response = lambda param: (self.gamma ** m(param)) * torch.exp(
-            -1j
-            * torch.einsum(
-                "fo, on -> fn",
-                self.omega,
-                m(param).unsqueeze(0),
+        if self.isint:
+            self.freq_response = lambda param: (self.gamma ** m(param).round()) * torch.exp(
+                -1j
+                * torch.einsum(
+                     "fo, on -> fn",
+                    self.omega,
+                    m(param).round().unsqueeze(0),
+                )
+            )
+        else:
+            self.freq_response = lambda param: (self.gamma ** m(param)) * torch.exp(
+                -1j
+                * torch.einsum(
+                    "fo, on -> fn",
+                    self.omega,
+                    m(param).unsqueeze(0),
+                )
             )
-        )
 
     def get_io(self):
         r"""

flamo-0.1.5/notebooks/e8_colorless_fdn.ipynb

@@ -0,0 +1,333 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training of a lossless FDN to improve colorlessness\n",
+    "Tune the parameters of an homogeneous and lossless FDN to reduce coloration\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Start from importing all the neccessary packages and flamo modules "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import os\n",
+    "from collections import OrderedDict\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# from flamo \n",
+    "from flamo.optimize.dataset import DatasetColorless, load_dataset\n",
+    "from flamo.optimize.trainer import Trainer\n",
+    "from flamo.processor import dsp, system\n",
+    "from flamo.optimize.loss import mse_loss, sparsity_loss\n",
+    "\n",
+    "torch.manual_seed(130798)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Construct the Feedback Delay Network\n",
+    "The FDN is created as an istance of the `flamo.system.Series`class which is used to cascade multiple DSP modules in series, similarly to `nn.Sequential`. This class serves as a container and ensures that all included modules share the same values for the `nfft` and `alias_decay_db` attributes. \n",
+    "\n",
+    "Note that the created FDN is lossless, so the `alias_decay_db` must be nonzero to reduce time-aliasing "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# FDN parameters\n",
+    "delay_lengths = torch.tensor([887, 911, 941, 1699, 1951, 2053])\n",
+    "N = len(delay_lengths)  # number of delays\n",
+    "\n",
+    "# training parameters\n",
+    "nfft = 2**16    # number of FFT points\n",
+    "alias_decay_db = 30  # decay in dB of the anti time-aliasing envelope\n",
+    "device = 'cpu'  # 'cuda' or 'cpu'\n",
+    "fs = 48000  # sample rate\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Input gains \n",
+    "input_gain = dsp.Gain(\n",
+    "    size=(N, 1), \n",
+    "    nfft=nfft, \n",
+    "    requires_grad=True, \n",
+    "    alias_decay_db=alias_decay_db, \n",
+    "    device=device\n",
+    ")\n",
+    "\n",
+    "# Output gains\n",
+    "output_gain = dsp.Gain(\n",
+    "    size=(1, N), \n",
+    "    nfft=nfft, \n",
+    "    requires_grad=True, \n",
+    "    alias_decay_db=alias_decay_db, \n",
+    "    device=device\n",
+    ")\n",
+    "\n",
+    "# FEEDBACK LOOP\n",
+    "\n",
+    "# feedforward path with delays\n",
+    "delays = dsp.parallelDelay(\n",
+    "    size=(N,),\n",
+    "    max_len=delay_lengths.max(),\n",
+    "    nfft=nfft,\n",
+    "    isint=True,\n",
+    "    requires_grad=False,\n",
+    "    alias_decay_db=alias_decay_db,\n",
+    "    device=device,\n",
+    ")\n",
+    "delays.assign_value(delays.sample2s(delay_lengths))\n",
+    "\n",
+    "# Feedback path with orthogonal matrix\n",
+    "feedback = dsp.Matrix(\n",
+    "    size=(N, N),\n",
+    "    nfft=nfft,\n",
+    "    matrix_type=\"orthogonal\",\n",
+    "    requires_grad=True,\n",
+    "    alias_decay_db=alias_decay_db,\n",
+    "    device=device,\n",
+    ")\n",
+    "# Create recursion\n",
+    "feedback_loop = system.Recursion(fF=delays, fB=feedback)\n",
+    "\n",
+    "# Contruct the FDN\n",
+    "FDN = system.Series(OrderedDict({\n",
+    "    'input_gain': input_gain,\n",
+    "    'feedback_loop': feedback_loop,\n",
+    "    'output_gain': output_gain\n",
+    "}))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "flamo provides a `Shell` class where the differentiable system, in this case `FDN`, is connected to the input and output layers. \n",
+    "- The input will be an impulse in time domain, thus the input layer needs to transform it to frequency domain \n",
+    "- The target is the desired magnitude response, thus the input layers is the absolute value operation "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_layer = dsp.FFT(nfft) \n",
+    "output_layer = dsp.Transform(transform=lambda x : torch.abs(x))\n",
+    "# wrap the FDN in the Shell\n",
+    "model = system.Shell(\n",
+    "    core=FDN, \n",
+    "    input_layer=input_layer, \n",
+    "    output_layer=output_layer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To speed up training is good practice to make sure that the energy of the system is comparable to that of the target. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "H = model.get_freq_response(identity=False)\n",
+    "energy_H = torch.mean(torch.pow(torch.abs(H),2))\n",
+    "target_energy = 1\n",
+    "# apply energy normalization on input and output gains only\n",
+    "with torch.no_grad():\n",
+    "    core = model.get_core()\n",
+    "    core.input_gain.assign_value(torch.div(core.input_gain.param, torch.pow( energy_H / target_energy, 1/4)))\n",
+    "    core.output_gain.assign_value(torch.div(core.output_gain.param, torch.pow( energy_H / target_energy, 1/4)))\n",
+    "    model.set_core(core)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Log impulse response and the magnitude response at initialization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with torch.no_grad():\n",
+    "    ir_init =  model.get_time_response(identity=False, fs=fs).squeeze() \n",
+    "    mag_init = model.get_freq_response(identity=False, fs=fs).squeeze() \n",
+    "    mag_init = 20 * torch.log10(mag_init)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Set up training\n",
+    "Set training parameters values and construct dataset and trainer. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# training set up parameters \n",
+    "batch_size = 1\n",
+    "num = 256 # number of samples\n",
+    "max_epochs = 20 # maximum number of epochs \n",
+    "lr = 1e-3 # learning rate\n",
+    "step_size = 5 # step size for the learning rate scheduler\n",
+    "train_dir = 'output/ex_fdn'\n",
+    "# create the output directory\n",
+    "os.makedirs(train_dir, exist_ok=True)\n",
+    "\n",
+    "# create the dataset and data loaders \n",
+    "dataset = DatasetColorless(\n",
+    "    input_shape=(1, nfft // 2 + 1, 1),      # impulse \n",
+    "    target_shape=(1, nfft // 2 + 1, 1),     # flat spectrum as target \n",
+    "    expand=num,\n",
+    "    device=device,\n",
+    ")\n",
+    "train_loader, valid_loader = load_dataset(dataset, batch_size=batch_size)\n",
+    "\n",
+    "# Initialize training process\n",
+    "trainer = Trainer(\n",
+    "    model, \n",
+    "    max_epochs=max_epochs, \n",
+    "    lr=lr, \n",
+    "    train_dir=train_dir, \n",
+    "    device=device)\n",
+    "\n",
+    "# Register the loss functions with their relative weights\n",
+    "trainer.register_criterion(mse_loss(), 1)\n",
+    "trainer.register_criterion(sparsity_loss(), 1, requires_model=True)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Train the model! \n",
+    "For each epoch the trainer launch both training and validation "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trainer.train(train_loader, valid_loader)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Get optimized impulse response\n",
+    "with torch.no_grad():\n",
+    "    ir_optim =  model.get_time_response(identity=False, fs=fs).squeeze()\n",
+    "    mag_optim = model.get_freq_response(identity=False, fs=fs).squeeze() \n",
+    "    mag_optim = 20 * torch.log10(mag_optim)\n",
+    "\n",
+    "time_axis = torch.linspace(0, nfft/fs, nfft)\n",
+    "freq_axis = torch.linspace(0, fs/2, nfft//2+1)\n",
+    "\n",
+    "# plot impulse response\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "plt.subplot(2, 1, 1)\n",
+    "plt.plot(time_axis, ir_init.numpy(), label='Initial')\n",
+    "plt.plot(time_axis, ir_optim.numpy(), label='Optimized', alpha=0.7)\n",
+    "plt.xlim(0, 0.5)\n",
+    "plt.legend()\n",
+    "plt.title('Impulse Response')\n",
+    "plt.xlabel('Samples')\n",
+    "plt.ylabel('Amplitude')\n",
+    "\n",
+    "# plot magnitude response\n",
+    "plt.subplot(2, 1, 2)\n",
+    "plt.plot(freq_axis, mag_init.numpy(), label='Initial')\n",
+    "plt.plot(freq_axis, mag_optim.numpy(), label='Optimized', alpha=0.7)\n",
+    "plt.xlim(100, 500)\n",
+    "plt.legend()\n",
+    "plt.title('Magnitude Response')\n",
+    "plt.xlabel('Frequency (Hz)')\n",
+    "plt.ylabel('Magnitude')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from IPython.display import Audio\n",
+    "\n",
+    "# Play the initial impulse response\n",
+    "print(\"Initial Impulse Response:\")\n",
+    "display(Audio(ir_init.numpy(), rate=fs))\n",
+    "\n",
+    "# Play the optimized impulse response\n",
+    "print(\"Optimized Impulse Response:\")\n",
+    "display(Audio(ir_optim.numpy(), rate=fs))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".flamo-env",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

{flamo-0.1.4 → flamo-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flamo"
-version = "0.1.4"
+version = "0.1.5"
 authors = [
   { name="Gloria Dal Santo", email="gloria.dalsanto@aalto.fi" },
   { name="Gian Marco De Bortoli", email="gian.debortoli@aalto.fi"},
@@ -34,6 +34,7 @@ dependencies = [
     "pydantic",
     "nnAudio",
     "pyfar",
+    "pyyaml"
 ]
 
 [project.urls]