qilisdk 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

qilisdk/{common → optimizers}/optimizer_result.py

@@ -13,17 +13,14 @@
 # limitations under the License.
 from __future__ import annotations
 
+from qilisdk.core.result import Result
 from qilisdk.yaml import yaml
 
 
 @yaml.register_class
-class OptimizerIntermediateResult:
+class OptimizerIntermediateResult(Result):
     """
     Represents an intermediate result.
-
-    Attributes:
-        cost (float): The optimal cost value (e.g., minimum energy) found.
-        parameters (List[float]): The parameters that yield the optimal cost.
     """
 
     def __init__(
@@ -50,15 +47,9 @@ class OptimizerIntermediateResult:
 
 
 @yaml.register_class
-class OptimizerResult:
+class OptimizerResult(Result):
     """
     Represents the result of an optimization run.
-
-    Attributes:
-        optimal_cost (float): The optimal cost value (e.g., minimum energy) found.
-        optimal_parameters (List[float]): The parameters that yield the optimal cost.
-        intermediate_results (List[OptimizerResult]): A list of intermediate optimization results.
-            Each intermediate result is an instance of OptimizerResult containing the current cost and parameters.
     """
 
     def __init__(

qilisdk/{common/optimizer.py → optimizers/scipy_optimizer.py}

@@ -11,39 +11,19 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
-from abc import ABC, abstractmethod
-from typing import Any, Callable
+from typing import TYPE_CHECKING, Any, Callable
 
 from scipy import optimize as scipy_optimize
-from scipy.optimize import OptimizeResult
 
 from qilisdk.yaml import yaml
 
+from .optimizer import Optimizer
 from .optimizer_result import OptimizerIntermediateResult, OptimizerResult
 
-
-class Optimizer(ABC):
-    @abstractmethod
-    def optimize(
-        self,
-        cost_function: Callable[[list[float]], float],
-        init_parameters: list[float],
-        store_intermediate_results: bool = False,
-    ) -> OptimizerResult:
-        """
-        Optimize the cost function and return an OptimizerResult.
-
-        Args:
-            cost_function (Callable[[List[float]], float]): A function that takes a list of parameters and returns the cost.
-            init_parameters (List[float]): The initial parameters for the optimization.
-            store_intermediate_results (bool, optional): If True, stores a list of intermediate optimization results.
-                Each intermediate result is recorded as an OptimizerResult containing the parameters and cost at that iteration.
-                Defaults to False.
-
-        Returns:
-            OptimizerResult: An object containing the optimal cost, optimal parameters, and, if requested, the intermediate results.
-        """
+if TYPE_CHECKING:
+    from scipy.optimize import OptimizeResult
 
 
 @yaml.register_class
@@ -82,8 +62,8 @@ class SciPyOptimizer(Optimizer):
                     for each element in parameter list.
 
         Extra Args:
-            Any argument supported by `scipy.optimize.minimize <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html>`__ can be passed.
-            Note: the parameters, cost function and the ``args``that are passed to this function will be specified in the optimize method. Moreover, callbacks are not supported for the moment.
+            Any argument supported by `scipy.optimize.minimize <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html>` can be passed.
+            Note: the parameters, cost function and the ``args`` that are passed to this function will be specified in the optimize method. Moreover, callbacks are not supported for the moment.
         """
         super().__init__()
         self.method = method
@@ -93,6 +73,7 @@ class SciPyOptimizer(Optimizer):
         self,
         cost_function: Callable[[list[float]], float],
         init_parameters: list[float],
+        bounds: list[tuple[float, float]],
         store_intermediate_results: bool = False,
     ) -> OptimizerResult:
         """optimize the cost function and return the optimal parameters.
@@ -100,6 +81,7 @@ class SciPyOptimizer(Optimizer):
         Args:
             cost_function (Callable[[list[float]], float]): a function that takes in a list of parameters and returns the cost.
             init_parameters (list[float]): the list of initial parameters. Note: the length of this list determines the number of parameters the optimizer will consider.
+            bounds (list[float, float]): a list of the variable value bounds.
 
         Returns:
             list[float]: the optimal set of parameters that minimize the cost function.
@@ -119,10 +101,10 @@ class SciPyOptimizer(Optimizer):
             cost_function,
             x0=init_parameters,
             method=self.method,
+            bounds=bounds,
             jac=self.extra_arguments.get("jac", None),
             hess=self.extra_arguments.get("hess", None),
             hessp=self.extra_arguments.get("hessp", None),
-            bounds=self.extra_arguments.get("bounds", None),
             constraints=self.extra_arguments.get("constraints", ()),
             tol=self.extra_arguments.get("tol", None),
             options=self.extra_arguments.get("options", None),

qilisdk/settings.py

@@ -0,0 +1,78 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from enum import Enum
+from functools import lru_cache
+from pathlib import Path
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def default_logging_config_path() -> Path:
+    return Path(__file__).with_name("logging_config.yaml").resolve()
+
+
+class Precision(str, Enum):
+    COMPLEX_64 = "COMPLEX_64"
+    COMPLEX_128 = "COMPLEX_128"
+
+
+class QiliSDKSettings(BaseSettings):
+    """
+    Environment-based configuration settings for QiliSDK.
+
+    These settings are automatically loaded from environment variables
+    prefixed with `QILISDK_`, or from a local `.env` file if present.
+    """
+
+    model_config = SettingsConfigDict(env_prefix="qilisdk_", env_file=".env", env_file_encoding="utf-8")
+
+    arithmetic_precision: Precision = Field(
+        default=Precision.COMPLEX_128, description="[env: QILISDK_ARITHMETIC_PRECISION]"
+    )
+    logging_config_path: Path = Field(
+        default_factory=default_logging_config_path,
+        description="YAML file used for logging configuration. [env: QILISDK_LOGGING_CONFIG_PATH]",
+    )
+    speqtrum_username: str | None = Field(
+        default=None,
+        description="SpeQtrum username used for authentication. [env: QILISDK_SPEQTRUM_USERNAME]",
+    )
+    speqtrum_apikey: str | None = Field(
+        default=None,
+        description="SpeQtrum API key associated with the user account. [env: QILISDK_SPEQTRUM_APIKEY]",
+    )
+    speqtrum_api_url: str = Field(
+        default="https://qilimanjaro.ddns.net/public-api/api/v1",
+        description="Base URL of the SpeQtrum API endpoint. [env: QILISDK_SPEQTRUM_API_URL]",
+    )
+    speqtrum_audience: str = Field(
+        default="urn:qilimanjaro.tech:public-api:beren",
+        description="Audience claim expected in the JWT used for authentication. [env: QILISDK_SPEQTRUM_AUDIENCE]",
+    )
+
+
+@lru_cache(maxsize=1)
+def get_settings() -> QiliSDKSettings:
+    """
+    Returns a singleton instance of QiliSDKSettings.
+
+    This function caches the parsed environment-based settings to avoid
+    redundant re-parsing across the application lifecycle.
+
+    Returns:
+        QiliSDKSettings: The cached configuration object populated from environment variables.
+    """
+    return QiliSDKSettings()

qilisdk/speqtrum/__init__.py

@@ -0,0 +1,41 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import sys
+
+from qilisdk._optionals import ImportedFeature, OptionalFeature, Symbol, import_optional_dependencies
+
+__all__ = []
+
+OPTIONAL_FEATURES: list[OptionalFeature] = [
+    OptionalFeature(
+        name="speqtrum",
+        dependencies=["httpx", "keyring", "keyrings-alt"],
+        symbols=[
+            Symbol(path="qilisdk.speqtrum.speqtrum", name="SpeQtrum"),
+            Symbol(path="qilisdk.speqtrum.speqtrum_models", name="DeviceStatus"),
+            Symbol(path="qilisdk.speqtrum.speqtrum_models", name="DeviceType"),
+            Symbol(path="qilisdk.speqtrum.speqtrum_models", name="JobHandle"),
+            Symbol(path="qilisdk.speqtrum.speqtrum_models", name="TypedJobDetail"),
+        ],
+    ),
+]
+
+current_module = sys.modules[__name__]
+
+# Dynamically import (or stub) each feature's symbols and attach them
+for feature in OPTIONAL_FEATURES:
+    imported_feature: ImportedFeature = import_optional_dependencies(feature)
+    for symbol_name, symbol_obj in imported_feature.symbols.items():
+        setattr(current_module, symbol_name, symbol_obj)
+        __all__ += [symbol_name]  # noqa: PLE0604

qilisdk/{extras → speqtrum}/__init__.pyi

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .cuda.cuda_backend import CudaBackend
-from .qaas.qaas_backend import QaaSBackend
+from .speqtrum import SpeQtrum
+from .speqtrum_models import DeviceStatus, DeviceType
 
-__all__ = ["CudaBackend", "QaaSBackend"]
+__all__ = ["DeviceStatus", "DeviceType", "SpeQtrum"]

qilisdk/speqtrum/experiments/__init__.py

@@ -0,0 +1,25 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from .experiment_functional import ExperimentFunctional, RabiExperiment, T1Experiment
+from .experiment_result import Dimension, ExperimentResult, RabiExperimentResult, T1ExperimentResult
+
+__all__ = [
+    "Dimension",
+    "ExperimentFunctional",
+    "ExperimentResult",
+    "RabiExperiment",
+    "RabiExperimentResult",
+    "T1Experiment",
+    "T1ExperimentResult",
+]

qilisdk/speqtrum/experiments/experiment_functional.py

@@ -0,0 +1,124 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING, ClassVar, Generic, TypeVar
+
+from qilisdk.functionals.functional import Functional
+from qilisdk.speqtrum.experiments.experiment_result import (
+    ExperimentResult,
+    RabiExperimentResult,
+    T1ExperimentResult,
+)
+from qilisdk.yaml import yaml
+
+if TYPE_CHECKING:
+    import numpy as np
+
+TResult_co = TypeVar("TResult_co", bound=ExperimentResult, covariant=True)
+
+
+@yaml.register_class
+class ExperimentFunctional(Functional, ABC, Generic[TResult_co]):
+    """Abstract base class for single-qubit experiment functionals.
+
+    This class serves as a generic interface for defining quantum
+    characterization experiments such as Rabi or T1. Each subclass
+    specifies a concrete `ExperimentResult` type and the corresponding
+    sweep parameters.
+    """
+
+    def __init__(self, qubit: int) -> None:
+        """Initialize the experiment functional.
+
+        Args:
+            qubit (int): The physical qubit index on which the experiment is performed.
+        """
+        self._qubit = qubit
+
+    @property
+    def qubit(self) -> int:
+        """The physical qubit index on which the experiment is performed.
+
+        Returns:
+            int: Index of the qubit.
+        """
+        return self._qubit
+
+
+@yaml.register_class
+class RabiExperiment(ExperimentFunctional[RabiExperimentResult]):
+    """Rabi experiment functional for a single qubit.
+
+    This functional defines a standard Rabi oscillation experiment where
+    the drive pulse duration is swept to measure the oscillatory response
+    of the qubit under continuous driving.
+    """
+
+    result_type: ClassVar[type[RabiExperimentResult]] = RabiExperimentResult
+    """Result type returned by this functional."""
+
+    def __init__(self, qubit: int, drive_duration_values: np.ndarray) -> None:
+        """Initialize a Rabi experiment functional.
+
+        Args:
+            qubit (int): The physical qubit index on which the experiment is performed.
+            drive_duration_values (np.ndarray): Array of drive pulse durations (in nanoseconds)
+                used to sweep the experiment.
+        """
+        super().__init__(qubit=qubit)
+        self._drive_duration_values = drive_duration_values
+
+    @property
+    def drive_duration_values(self) -> np.ndarray:
+        """Drive pulse duration sweep values.
+
+        Returns:
+            np.ndarray: The set of drive durations (in nanoseconds) used in the Rabi experiment.
+        """
+        return self._drive_duration_values
+
+
+@yaml.register_class
+class T1Experiment(ExperimentFunctional[T1ExperimentResult]):
+    """T1 relaxation experiment functional for a single qubit.
+
+    This functional defines a standard T1 (energy relaxation) experiment,
+    where the delay between excitation and measurement is varied to extract
+    the relaxation time constant of the qubit.
+    """
+
+    result_type: ClassVar[type[T1ExperimentResult]] = T1ExperimentResult
+    """Result type returned by this functional."""
+
+    def __init__(self, qubit: int, wait_duration_values: np.ndarray) -> None:
+        """Initialize a T1 experiment functional.
+
+        Args:
+            qubit (int): The physical qubit index on which the experiment is performed.
+            wait_duration_values (np.ndarray): Array of waiting times (in nanoseconds)
+                between excitation and measurement.
+        """
+        super().__init__(qubit=qubit)
+        self._wait_duration_values: np.ndarray = wait_duration_values
+
+    @property
+    def wait_duration_values(self) -> np.ndarray:
+        """Waiting time sweep values.
+
+        Returns:
+            np.ndarray: The set of delay durations (in nanoseconds) used in the T1 experiment.
+        """
+        return self._wait_duration_values

qilisdk/speqtrum/experiments/experiment_result.py

@@ -0,0 +1,231 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from pathlib import Path
+from typing import ClassVar
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.figure import Figure
+
+from qilisdk.functionals.functional_result import FunctionalResult
+from qilisdk.yaml import yaml
+
+
+@yaml.register_class
+class Dimension:
+    """Represents a labeled dimension in an experiment sweep.
+
+    A `Dimension` defines one or more sweep parameters, such as drive
+    amplitude, frequency, or delay time, together with their associated
+    numerical values.
+
+    Attributes:
+        labels (list[str]): Human-readable labels for the sweep parameters.
+        values (list[np.ndarray]): Numeric arrays representing the values
+            corresponding to each label.
+    """
+
+    def __init__(self, labels: list[str], values: list[np.ndarray]) -> None:
+        """Initialize a Dimension object.
+
+        Args:
+            labels (list[str]): Labels describing each dimension (e.g. ``["Drive amplitude"]``).
+            values (list[np.ndarray]): Numerical arrays for the corresponding parameter values.
+        """
+        self.labels = labels
+        self.values = values
+
+
+@yaml.register_class
+class ExperimentResult(FunctionalResult):
+    """Base class for storing and visualizing experiment results.
+
+    This class defines common utilities for handling experimental data,
+    including computation of S21 parameters and automatic 1D or 2D plotting.
+    Subclasses provide specific sweep parameters and plot titles.
+    """
+
+    plot_title: ClassVar[str]
+    """Default plot title; subclasses provide the concrete label."""
+
+    def __init__(self, qubit: int, data: np.ndarray, dims: list[Dimension]) -> None:
+        """Initialize an experiment result.
+
+        Args:
+            qubit (int): The qubit index on which the experiment was performed.
+            data (np.ndarray): Raw experimental data array.
+            dims (list[Dimension]): Sweep dimensions of the experiment.
+        """
+        self.qubit = qubit
+        self.data = data
+        self.dims = dims
+
+    @property
+    def s21(self) -> np.ndarray:
+        """Complex S21 transmission parameter.
+
+        Returns:
+            np.ndarray: The complex-valued S21 response computed as ``Re + i * Im``.
+        """
+        return self.data[..., 0] + 1j * self.data[..., 1]
+
+    @property
+    def s21_modulus(self) -> np.ndarray:
+        """Magnitude of the S21 parameter.
+
+        Returns:
+            np.ndarray: The absolute value of the S21 parameter.
+        """
+        return np.abs(self.s21)
+
+    @property
+    def s21_db(self) -> np.ndarray:
+        """Magnitude of S21 in decibels (dB).
+
+        Returns:
+            np.ndarray: ``20 * log10(abs(S21))`` expressed in dB.
+        """
+        return 20 * np.log10(self.s21_modulus)
+
+    def plot(self, save_to: str | None = None) -> None:
+        """Plot the S21 parameter from experiment results.
+
+        Automatically detects whether the dataset is 1D or 2D and creates
+        the appropriate figure. Optionally saves the figure to disk.
+
+        Args:
+            save_to (str | None): Optional path or directory to save the
+                generated plot. If a directory is provided, the filename is
+                automatically generated as ``{plot_title}_qubit{qubit}.png``.
+
+        Raises:
+            NotImplementedError: If the experiment data has more than 2 dimensions.
+        """
+
+        def save_figure(figure: Figure, save_to: str | Path) -> None:
+            save_to = Path(save_to)
+
+            # If a directory was given, append the default filename
+            if save_to.is_dir():
+                save_to /= f"{self.plot_title}_qubit{self.qubit}.png"
+
+            save_to.parent.mkdir(parents=True, exist_ok=True)
+            figure.savefig(save_to)
+
+        def plot_1d(s21: np.ndarray, dims: list[Dimension]) -> None:
+            """Plot 1d"""
+            x_labels, x_values = dims[0].labels, dims[0].values
+
+            fig, ax1 = plt.subplots()
+            ax1.set_title(f"{self.plot_title} - Qubit {self.qubit}")
+            ax1.set_xlabel(x_labels[0])
+            ax1.set_ylabel(r"$|S_{21}|$")
+            ax1.plot(x_values[0], s21, ".")
+
+            if len(x_labels) > 1:
+                # Create secondary x-axis
+                ax2 = ax1.twiny()
+
+                # Set labels
+                ax2.set_xlabel(x_labels[1])
+                ax2.set_xlim(min(x_values[1]), max(x_values[1]))
+
+                # Set tick locations
+                ax2_ticks = np.linspace(min(x_values[1]), max(x_values[1]), num=6)
+                ax2.set_xticks(ax2_ticks)
+
+                # Force scientific notation
+                ax2.ticklabel_format(axis="x", style="sci", scilimits=(-3, 3))
+
+            if save_to:
+                save_figure(fig, save_to)
+
+            plt.show()
+
+        # pylint: disable=too-many-locals
+        def plot_2d(s21: np.ndarray, dims: list[Dimension]) -> None:
+            """Plot 2d"""
+            x_labels, x_values = dims[0].labels, dims[0].values
+            y_labels, y_values = dims[1].labels, dims[1].values
+
+            # Create x and y edge arrays by extrapolating the edges
+            x_edges = np.linspace(x_values[0].min(), x_values[0].max(), len(x_values[0]) + 1)
+            y_edges = np.linspace(y_values[0].min(), y_values[0].max(), len(y_values[0]) + 1)
+
+            fig, ax1 = plt.subplots()
+            ax1.set_title(f"{self.plot_title} - Qubit {self.qubit}")
+            ax1.set_xlabel(x_labels[0])
+            ax1.set_ylabel(y_labels[0])
+
+            # Force scientific notation
+            ax1.ticklabel_format(axis="both", style="sci", scilimits=(-3, 3))
+
+            mesh = ax1.pcolormesh(x_edges, y_edges, s21.T, cmap="viridis", shading="auto")
+            fig.colorbar(mesh, ax=ax1)
+
+            if len(x_labels) > 1:
+                # Create secondary x-axis
+                ax2 = ax1.twiny()
+
+                # Set labels
+                ax2.set_xlabel(x_labels[1])
+                ax2.set_xlim(min(x_values[1]), max(x_values[1]))
+
+                # Set tick locations
+                ax2_ticks = np.linspace(min(x_values[1]), max(x_values[1]), num=6)
+                ax2.set_xticks(ax2_ticks)
+
+                # Force scientific notation
+                ax2.ticklabel_format(axis="x", style="sci", scilimits=(-3, 3))
+            if len(y_labels) > 1:
+                ax3 = ax1.twinx()
+                ax3.set_ylabel(y_labels[1])
+                ax3.set_ylim(min(y_values[1]), max(y_values[1]))
+
+                # Set tick locations
+                ax3_ticks = np.linspace(min(y_values[1]), max(y_values[1]), num=6)
+                ax3.set_xticks(ax3_ticks)
+
+                # Force scientific notation
+                ax3.ticklabel_format(axis="y", style="sci", scilimits=(-3, 3))
+
+            if save_to:
+                save_figure(fig, save_to)
+
+            plt.tight_layout()
+            plt.show()
+
+        n_dimensions = len(self.s21_modulus.shape)
+        if n_dimensions == 1:
+            plot_1d(self.s21_modulus, self.dims)
+        elif n_dimensions == 2:  # noqa: PLR2004
+            plot_2d(self.s21_modulus, self.dims)
+        else:
+            raise NotImplementedError("3D and higher dimension plots are not supported yet.")
+
+
+@yaml.register_class
+class RabiExperimentResult(ExperimentResult):
+    """Result container for Rabi experiments."""
+
+    plot_title: ClassVar[str] = "Rabi"
+    """Default title for Rabi experiment plots."""
+
+
+@yaml.register_class
+class T1ExperimentResult(ExperimentResult):
+    """Result container for T1 relaxation experiments."""
+
+    plot_title: ClassVar[str] = "T1"
+    """Default title for T1 experiment plots."""

qilisdk/{extras/qaas → speqtrum}/keyring.py

@@ -13,11 +13,12 @@
 # limitations under the License.
 
 import keyring
+from keyring.errors import PasswordDeleteError
 from pydantic import ValidationError
 
-from .models import Token
+from .speqtrum_models import Token
 
-KEYRING_IDENTIFIER = "QaaSKeyring"
+KEYRING_IDENTIFIER = "SpeQtrumKeyring"
 
 
 def store_credentials(username: str, token: Token) -> None:
@@ -32,8 +33,11 @@ def delete_credentials() -> None:
     """
     Delete username and token from the keyring.
     """
-    keyring.delete_password(KEYRING_IDENTIFIER, "username")
-    keyring.delete_password(KEYRING_IDENTIFIER, "token")
+    try:
+        keyring.delete_password(KEYRING_IDENTIFIER, "username")
+        keyring.delete_password(KEYRING_IDENTIFIER, "token")
+    except PasswordDeleteError:
+        return
 
 
 def load_credentials() -> tuple[str, Token] | None: