sqil-core 0.0.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

sqil_core/utils/_read.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from typing import TYPE_CHECKING
+
+import h5py
+import numpy as np
+import yaml
+from laboneq import serializers
+
+from sqil_core.utils._formatter import param_info_from_schema
+
+from ._const import _EXP_UNIT_MAP, PARAM_METADATA
+
+if TYPE_CHECKING:
+    from laboneq.dsl.quantum.qpu import QPU
+
+
+# TODO: add tests for schema
+def extract_h5_data(
+    path: str, keys: list[str] | None = None, schema=False
+) -> dict | tuple[np.ndarray, ...]:
+    """Extract data at the given keys from an HDF5 file. If no keys are
+    given (None) returns the data field of the object.
+
+    Parameters
+    ----------
+    path : str
+        path to the HDF5 file or a folder in which is contained a data.ddh5 file
+    keys : None or List, optional
+        list of keys to extract from file['data'], by default None
+
+    Returns
+    -------
+    Dict or Tuple[np.ndarray, ...]
+        The full data dictionary if keys = None.
+        The tuple with the requested keys otherwise.
+
+    Example
+    -------
+        Extract the data object from the dataset:
+        >>> data = extract_h5_data(path)
+        Extracting only 'amp' and 'phase' from the dataset:
+        >>> amp, phase = extract_h5_data(path, ['amp', 'phase'])
+        Extracting only 'phase':
+        >>> phase, = extract_h5_data(path, ['phase'])
+    """
+    # If the path is to a folder open /data.ddh5
+    if os.path.isdir(path):
+        path = os.path.join(path, "data.ddh5")
+
+    with h5py.File(path, "r") as h5file:
+        data = h5file["data"]
+        data_keys = data.keys()
+
+        db_schema = None
+        if schema:
+            db_schema = json.loads(data.attrs.get("__schema__"))
+
+        # Extract only the requested keys
+        if bool(keys) and (len(keys) > 0):
+            res = []
+            for key in keys:
+                key = str(key)
+                if (not bool(key)) | (key not in data_keys):
+                    res.append([])
+                    continue
+                res.append(np.array(data[key][:]))
+            if not schema and len(res) == 1:
+                return res[0]
+            return tuple(res) if not schema else (*tuple(res), db_schema)
+        # Extract the whole data dictionary
+        h5_dict = _h5_to_dict(data)
+        return h5_dict if not schema else {**h5_dict, "schema": db_schema}
+    #
+
+
+def _h5_to_dict(obj) -> dict:
+    """Convert h5 data into a dictionary"""
+    data_dict = {}
+    for key in obj.keys():
+        item = obj[key]
+        if isinstance(item, h5py.Dataset):
+            data_dict[key] = item[:]
+        elif isinstance(item, h5py.Group):
+            data_dict[key] = extract_h5_data(item)
+    return data_dict
+
+
+def map_data_dict(data_dict: dict):
+    """
+    Maps experimental data to standardized arrays using a provided schema.
+
+    This function interprets the structure of a measurement data dictionary
+    (obtained using extract_h5_data) by extracting relevant data fields according
+    to roles specified in the database schema. It returns the x-axis values, y-axis data,
+    any additional sweep parameters, and a mapping of keys used for each role.
+
+    Parameters
+    ----------
+    data_dict : dict
+        Dictionary containing measurement data and an associated 'schema' key
+        that defines the role of each field (e.g., "x-axis", "data", "axis").
+
+    Returns
+    -------
+    x_data : np.ndarray
+        Array containing the x-axis values.
+    y_data : np.ndarray
+        Array containing the y-axis (measured) data.
+    sweeps : list[np.ndarray]
+        List of additional swept parameter arrays (if any).
+    key_map : dict
+        Dictionary with keys `"x_data"`, `"y_data"`, and `"sweeps"` indicating
+        the corresponding keys used in the original `data_dict`.
+
+    Notes
+    -----
+    - If the schema is missing, the function prints a warning and returns empty arrays.
+    - Each item in the schema must be a dictionary with a `"role"` key.
+
+    Examples
+    --------
+    >>> x, y, sweeps, mapping = map_data_dict(experiment_data)
+    >>> print(f"x-axis data from key: {mapping['x_data']}")
+    """
+
+    schema = data_dict.get("schema", None)
+    if schema is None:
+        print(
+            "Cannot automatically read data: no database schema was provided by the experiment."
+        )
+
+    x_data, y_data, sweeps = np.array([]), np.array([]), []
+    key_map = {"x_data": "", "y_data": "", "sweeps": []}
+
+    for key, value in schema.items():
+        if type(value) is not dict:
+            continue
+        role = value.get("role", None)
+        if role == "data":
+            key_map["y_data"] = key
+            y_data = data_dict[key]
+        elif role == "x-axis":
+            key_map["x_data"] = key
+            x_data = data_dict[key]
+        elif role == "axis":
+            key_map["sweeps"].append(key)
+            sweeps.append(data_dict[key])
+
+    return x_data, y_data, sweeps, key_map
+
+
+def extract_mapped_data(path: str):
+    """
+    Loads measurement data from an HDF5 file and maps it into x_data, y_data and sweeps.
+    The map and the database schema on which it relies are also returned.
+
+    Parameters
+    ----------
+    path : str or Path
+        Path to the HDF5 file containing experimental data and schema definitions.
+
+    Returns
+    -------
+    x_data : np.ndarray
+        Array of x-axis values extracted according to the schema.
+    y_data : np.ndarray
+        Array of measured data values (y-axis).
+    sweeps : list[np.ndarray]
+        List of arrays for any additional swept parameters defined in the schema.
+    datadict_map : dict
+        Mapping of keys used for `"x_data"`, `"y_data"`, and `"sweeps"` in the original file.
+    schema : dict
+        The schema used to interpret the data structure and field roles.
+
+    Notes
+    -----
+    - This function expects the file to contain a top-level "schema" key that defines the
+      role of each dataset (e.g., "data", "x-axis", "axis").
+    - Uses `extract_h5_data` and `map_data_dict` internally for loading and interpretation.
+
+    Examples
+    --------
+    >>> x, y, sweeps, datadict_map, schema = extract_mapped_data(path)
+    """
+
+    datadict = extract_h5_data(path, schema=True)
+    schema = datadict.get("schema")
+    x_data, y_data, sweeps, datadict_map = map_data_dict(datadict)
+    return x_data, y_data, sweeps, datadict_map, schema
+
+
+def get_data_and_info(path=None, datadict=None):
+    if path is None and datadict is None:
+        raise Exception("At least one of `path` and `datadict` must be specified.")
+
+    if path is not None:
+        datadict = extract_h5_data(path, schema=True)
+
+    # Get schema and map data
+    schema = datadict.get("schema")
+    x_data, y_data, sweeps, datadict_map = map_data_dict(datadict)
+
+    # Get metadata on x_data and y_data
+    x_info = param_info_from_schema(
+        datadict_map["x_data"], schema[datadict_map["x_data"]]
+    )
+    y_info = param_info_from_schema(
+        datadict_map["y_data"], schema[datadict_map["y_data"]]
+    )
+
+    sweep_info = []
+    for sweep_key in datadict_map["sweeps"]:
+        sweep_info.append(param_info_from_schema(sweep_key, schema[sweep_key]))
+
+    return (x_data, y_data, sweeps), (x_info, y_info, sweep_info), datadict
+
+
+def read_json(path: str) -> dict:
+    """Reads a json file and returns the data as a dictionary."""
+    with open(path) as f:
+        dictionary = json.load(f)
+    return dictionary
+
+
+def read_yaml(path: str) -> dict:
+    with open(path) as stream:
+        try:
+            return yaml.safe_load(stream)
+        except yaml.YAMLError as exc:
+            print(exc)
+
+
+def read_qpu(dir_path: str, filename: str) -> QPU:
+    """Reads QPU file stored in dir_path/filename using laboneq serializers."""
+    qpu = serializers.load(os.path.join(dir_path, filename))
+    return qpu
+
+
+def get_measurement_id(path):
+    return os.path.basename(path)[0:5]
+
+
+def copy_folder(src: str, dst: str):
+    # Ensure destination exists
+    os.makedirs(dst, exist_ok=True)
+
+    # Copy files recursively
+    for root, dirs, files in os.walk(src):
+        for dir_name in dirs:
+            os.makedirs(
+                os.path.join(dst, os.path.relpath(os.path.join(root, dir_name), src)),
+                exist_ok=True,
+            )
+        for file_name in files:
+            shutil.copy2(
+                os.path.join(root, file_name),
+                os.path.join(dst, os.path.relpath(os.path.join(root, file_name), src)),
+            )

sqil_core/utils/_utils.py

@@ -0,0 +1,164 @@
+import hashlib
+import importlib.util
+import inspect
+import sys
+from collections.abc import Iterable
+
+from sqil_core.config_log import logger
+
+
+def fill_gaps(primary_list: list, fallback_list: list) -> list:
+    """
+    Fills gaps in the primary list using values from the fallback list.
+
+    This function iterates through two lists, and for each pair of elements,
+    it fills in the gaps where the element in the primary list is `None`
+    with the corresponding element from the fallback list. If the element
+    in the primary list is not `None`, it is kept as-is.
+
+    Parameters
+    ----------
+    primary_list : list
+        A list of values where some elements may be `None`, which will be replaced by values from `fallback_list`.
+    fallback_list : list
+        A list of values used to fill gaps in `primary_list`.
+
+    Returns
+    -------
+    result : list
+        A new list where `None` values in `primary_list` are replaced by corresponding values from `fallback_list`.
+
+    Examples
+    --------
+    >>> primary_list = [1, None, 3, None, 5]
+    >>> fallback_list = [10, 20, 30, 40, 50]
+    >>> fill_gaps(primary_list, fallback_list)
+    [1, 20, 3, 40, 5]
+    """
+    if (fallback_list is None) or (len(fallback_list) == 0):
+        return primary_list
+
+    if primary_list is None:
+        return fallback_list
+
+    if len(primary_list) == 0:
+        primary_list = []
+
+    result = primary_list
+    fallback_list = fallback_list[0 : len(primary_list)]
+    for i in range(len(fallback_list)):
+        if result[i] == None:
+            result[i] = fallback_list[i]
+
+    return result
+
+
+def make_iterable(obj) -> Iterable:
+    """
+    Ensures that the given object is an iterable.
+
+    If the input object is already an iterable (excluding strings), it is returned as-is.
+    Otherwise, it is wrapped in a list to make it iterable.
+
+    Parameters
+    ----------
+    obj : Any
+        The object to be converted into an iterable.
+
+    Returns
+    -------
+    iterable : Iterable
+        An iterable version of the input object. If the input is not already an iterable,
+        it is returned as a single-element list.
+
+    Examples
+    --------
+    >>> make_iterable(42)
+    [42]
+
+    >>> make_iterable([1, 2, 3])
+    [1, 2, 3]
+
+    >>> make_iterable("hello")
+    ["hello"]  # Strings are not treated as iterables in this function
+    """
+    if isinstance(obj, str):
+        return [obj]
+    return obj if isinstance(obj, Iterable) else [obj]
+
+
+def has_at_least_one(lst: list, value) -> bool:
+    """
+    Checks whether a given value appears at least once in a list.
+    If the object passed is not iterable, it is converted to an interable,
+    e.g. if lst = 5, the function transform lst = [lst].
+
+    Parameters
+    ----------
+    lst : list
+        The list to search.
+    value : Any
+        The value to look for in the list. If `None`, the function checks for the presence
+        of `None` using identity comparison.
+
+    Returns
+    -------
+    bool
+        True if the value appears at least once in the list; False otherwise.
+    """
+    lst = make_iterable(lst)
+
+    if value is None:
+        return any(x is None for x in lst)
+    else:
+        return any(x == value for x in lst)
+
+
+def _count_function_parameters(func):
+    sig = inspect.signature(func)
+    return len(
+        [
+            param
+            for param in sig.parameters.values()
+            if param.default == inspect.Parameter.empty
+            and param.kind
+            in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.POSITIONAL_ONLY,
+            )
+        ]
+    )
+
+
+def _extract_variables_from_module(module_name, path):
+    try:
+        spec = importlib.util.spec_from_file_location(module_name, path)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        spec.loader.exec_module(module)
+
+        # Get all variables and their values
+        variables = {
+            name: value
+            for name, value in vars(module).items()
+            if not name.startswith("__")
+        }
+        return variables
+
+    except Exception as e:
+        logger.error(f"Error while extracting variables from {path}: {str(e)}")
+
+    return {}
+
+
+def _hash_file(path):
+    """Generate a hash for the file using SHA256."""
+    sha256_hash = hashlib.sha256()
+    try:
+        with open(path, "rb") as file:
+            for byte_block in iter(lambda: file.read(4096), b""):
+                sha256_hash.update(byte_block)
+    except Exception as e:
+        logger.error(f"Unable to hash file '{path}': {str(e)}")
+        return None
+    return sha256_hash.hexdigest()

{sqil_core-0.0.2.dist-info → sqil_core-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: sqil-core
-Version: 0.0.2
+Version: 1.0.0
 Summary: The codebase of the SQIL group in EPFL
 Author: Andrea Duina
 Requires-Python: >=3.10,<4.0
@@ -9,12 +9,21 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: blinker (>=1.9.0,<2.0.0)
 Requires-Dist: h5py (>=3.12.1,<4.0.0)
 Requires-Dist: isort (==5.9.3)
+Requires-Dist: laboneq (>=2.54.0,<3.0.0)
+Requires-Dist: laboneq-applications (>=2.4.0,<3.0.0)
+Requires-Dist: lmfit (>=1.3.2,<2.0.0)
 Requires-Dist: matplotlib (>=3.9.3,<4.0.0)
-Requires-Dist: numpy (>=2.2.0,<3.0.0)
+Requires-Dist: mpld3 (>=0.5.10,<0.6.0)
+Requires-Dist: numpy (>=2.2.3,<3.0.0)
+Requires-Dist: plottr (>=0.14.0,<0.15.0)
+Requires-Dist: pyro5 (>=5.15,<6.0)
+Requires-Dist: qcodes (>=0.51.0,<0.52.0)
+Requires-Dist: qcodes-contrib-drivers (>=0.23.0,<0.24.0)
 Requires-Dist: scipy (>=1.14.1,<2.0.0)
-Requires-Dist: seaborn (>=0.13.2,<0.14.0)
+Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Description-Content-Type: text/markdown
 
 # For users
@@ -38,34 +47,44 @@ path = 'path to your data folder'
 mag, phase, freq = sqil.extract_h5_data(path, ['mag_dB', 'phase', 'ro_freq'])
 ```
 
+## Documentation
+You can find the documentation for this package [here](https://sqil-epfl.github.io/sqil-core/)
+
 # For developers
 
 ## Development
 
 1. **Install poetry if you haven't already**
+
 ```bash
 $ pip install poetry
+$ pip install poetry-plugin-shell
 ```
 
 2. **Install the required packages using poetry**
+
 ```bash
 $ poetry install
 ```
 
 3. **Install the pre-commit hooks**
-If you are on windows you need to install git ([https://git-scm.com/downloads](here)) and add it to your windows PATH.
-After the installation open a new terminal.
+   If you are on windows you need to install git ([https://git-scm.com/downloads](here)) and add it to your windows PATH.
+   After the installation open a new terminal.
+
 ```bash
 $ poetry run pre-commit install
 ```
+
 This will check if your python files are formatted correctly when you try to commit.
 If that's not the case the commit will be canceled and the files will be automatically formatted.
 Then you'll have to add and commit again the new files.
 
 4. **Start the virtual environment**
+
 ```bash
 $ poetry shell
 ```
+
 To exit the virtual environment just use `exit`
 
 #### Test your changes
@@ -91,7 +110,11 @@ $ poetry run build
 $ pip install PATH_TO_SQIL_CORE_FOLDER/dist/SQIL_CORE-VERSION.whl
 ```
 
-If you're using a jupyter notebook remember to restart the kernel
+If you're testing a new function remember to import it in the folder's `__init__.py` file.
+
+
+If you're using a jupyter notebook remember to restart the kernel.
+
 
 ## Build
 
@@ -99,6 +122,16 @@ If you're using a jupyter notebook remember to restart the kernel
 $ poetry run build
 ```
 
+## Publish
+
+To publish version X.X.X run the commands below. This will trigger a GitHub action that deploys to release to PyPi (pip) and GitHub.
+Remember also to change the version number in the `pyproject.toml` file.
+
+```bash
+$ git tag vX.X.X
+$ git push origin vX.X.X
+```
+
 ## Docs
 
 Serve docs

sqil_core-1.0.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+sqil_core/__init__.py,sha256=Bm5X6xWur6bzw9PGyrHBkBUYSkmrA32ufnrQIbuMDxE,236
+sqil_core/config.py,sha256=x7nNdIGJh_2jU6_WuyZ_VjjwkcvibAK-Rc-k0yePUFA,166
+sqil_core/config_log.py,sha256=sSj1HBembBYsos6ilf0V5ll_FBZCNNr9K8CYOS8xxWg,1221
+sqil_core/experiment/__init__.py,sha256=kIkwb1Yr-UYIM0XfD6IsQTI72nPD33JDHHSekXzlF68,389
+sqil_core/experiment/_analysis.py,sha256=3v4FmCaVkJobGWUSU--lcXvtk6Ex6GstG9IcP3L4BnE,3114
+sqil_core/experiment/_events.py,sha256=inPcGJu0iGqJKIeDRqDkSmwpgLb9ABzGF8U_ExqfoeY,693
+sqil_core/experiment/_experiment.py,sha256=FtFGvN5eAHQhfQm5X3dATXpUvCb6hVgsLObBUPVVtyQ,19823
+sqil_core/experiment/data/plottr.py,sha256=-hNvzM6u8hm6-5AjcQZMN85fZVP2E1SkrZEevJHoPi0,26481
+sqil_core/experiment/helpers/_function_override_handler.py,sha256=ldynTPQKifeCbx9OiCqs_KdH9MPYcy0aoToA16NFcCY,3463
+sqil_core/experiment/helpers/_labone_wrappers.py,sha256=YmmEoNFeQ53xsdvDM7KUluVqpoIimv-PS0QoZ85m6Cs,357
+sqil_core/experiment/instruments/__init__.py,sha256=V88fgDuu4J6swreuAKeGrc6_P0XZehlKnOVhw71weBk,82
+sqil_core/experiment/instruments/_instrument.py,sha256=WRYeqgVqfvcanpBBzrY8gx2XrGfntstMAiZidKAvvFE,6025
+sqil_core/experiment/instruments/drivers/SignalCore_SC5511A.py,sha256=dTH2mbFrTGKPnFL8Z2Kt-V7SOkHgYuOqqY1nyqftRlI,18257
+sqil_core/experiment/instruments/local_oscillator.py,sha256=07E7UVo4ZEV0ZyjCkmrbGJicV43TMtxsdvi4l-w4Dzg,6214
+sqil_core/experiment/instruments/server.py,sha256=veNRc0iRQav4EayHefBnwo9UYJj8lhIFD0L_PI1dwtM,6098
+sqil_core/experiment/instruments/setup.yaml,sha256=B1x3nzUuJZOKRcGY7RHOIoZeVxz2wnMOZY6mNGDAuV8,399
+sqil_core/experiment/instruments/zurich_instruments.py,sha256=g3QLZVBW2XP_GFFWlmgXmiSzelvoT8GKe4FzH7xW1zY,1880
+sqil_core/fit/__init__.py,sha256=xDLMBmWW29eZqfwBQHS5cLgIxJNPC5sCvS4CggiQhj0,817
+sqil_core/fit/_core.py,sha256=wL1XnM2LoYGlnlz1zRrtMKoVZC6aKE1Xbv6y8kBq1BY,41076
+sqil_core/fit/_fit.py,sha256=vb4DnjnvoVXQtF1WI_WHxfgdIw5Eqw4HV24DqKSJv6M,39297
+sqil_core/fit/_guess.py,sha256=EE8W65E3ljePNZ5-CmHyFUNUkhQwmF50zl-CALut2-Q,6961
+sqil_core/fit/_models.py,sha256=H3eAz3JyESprF_m7rY4_PBqCGt4sA94SxWcTrC9QZog,4131
+sqil_core/fit/_quality.py,sha256=e4IZvVk2hOvIaPuFaUobvgyT2zA5eji9KiHyoQetpc8,8772
+sqil_core/resonator/__init__.py,sha256=d8MYTwjEUetlw1d4MRcHwHQPYmiwxhn40fFhctWSNaY,254
+sqil_core/resonator/_resonator.py,sha256=qClDQFDHzg38oModL7ZxpsEUDpijxeDHyr_hv4b0t2g,35558
+sqil_core/utils/__init__.py,sha256=0y-yPGMOpU4En9xVfCWLTqfKt3ERpTgZknZAMbKnQqY,1950
+sqil_core/utils/_analysis.py,sha256=qDe914FQxJYneiRliMP1IgVoGDAFfddZ9yXUascVZjU,13435
+sqil_core/utils/_const.py,sha256=hHTAReTvm3UOIb2kj-oUQn4RKodjSXUnwB0V5cnDB0E,2406
+sqil_core/utils/_formatter.py,sha256=C_inxxGJ3xEbrWKjGy0xVNzjjNbDMQSCSkWuRMA1noQ,7907
+sqil_core/utils/_plot.py,sha256=u9OE9I3-xx3KsfMba3hZiIhneECiRBFxpe9HCi-1mU0,12813
+sqil_core/utils/_read.py,sha256=9TTYQDz0nm81PkvCQBjETFHwpJGBtK5HprjhzxVY2ps,8432
+sqil_core/utils/_utils.py,sha256=GU0eLO73Lil8yFj9aBWv_Q_dCZZHepSW4emhFOcP0Yc,4652
+sqil_core-1.0.0.dist-info/METADATA,sha256=zshSJ-TMAfgx6zpvecwx7OMvTNTJc3lFo5BAW5hgg5U,3347
+sqil_core-1.0.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+sqil_core-1.0.0.dist-info/entry_points.txt,sha256=mnYKe0NKDcT5Py_8cL44TgcbLVOUS-CxmGBMEcsbGAQ,95
+sqil_core-1.0.0.dist-info/RECORD,,

{sqil_core-0.0.2.dist-info → sqil_core-1.0.0.dist-info}/WHEEL

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

{sqil_core-0.0.2.dist-info → sqil_core-1.0.0.dist-info}/entry_points.txt

@@ -1,5 +1,5 @@
 [console_scripts]
 build=scripts:build
 docs-build=scripts:docs_build
-docs-serve=scripts:docs_serve
+docs-dev=scripts:docs_dev
 

sqil_core/utils/analysis.py

@@ -1,68 +0,0 @@
-import numpy as np
-
-
-def remove_offset(data: np.ndarray, avg: int = 3) -> np.ndarray:
-    """Removes the initial offset from a data matrix or vector by subtracting
-    the average of the first `avg` points. After applying this function,
-    the first point of each column of the data will be shifted to (about) 0.
-
-    Parameters
-    ----------
-    data : np.ndarray
-        Input data, either a 1D vector or a 2D matrix
-    avg : int, optional
-        The number of initial points to average when calculating
-        the offset, by default 3
-
-    Returns
-    -------
-    np.ndarray
-       The input data with the offset removed
-    """
-    is1D = len(data.shape) == 1
-    if is1D:
-        return data - np.mean(data[0:avg])
-    return data - np.mean(data[:, 0:avg], axis=1).reshape(data.shape[0], 1)
-
-
-def estimate_linear_background(x: np.ndarray, data: np.ndarray, points_cut=0.1) -> list:
-    is1D = len(data.shape) == 1
-    points = data.shape[0] if is1D else data.shape[1]
-    cut = int(points * points_cut)
-
-    # Consider just the cut points
-    x_data = x[0:cut] if is1D else x[0:cut, :]
-    X = np.vstack([np.ones_like(x_data), x_data]).T
-    y_data = data[0:cut] if is1D else data[0:cut, :]
-
-    # Linear fit
-    coefficients, residuals, _, _ = np.linalg.lstsq(
-        X, y_data if is1D else y_data.T, rcond=None
-    )
-
-    return coefficients
-
-
-def remove_linear_background(
-    x: np.ndarray, data: np.ndarray, points_cut=0.1
-) -> np.ndarray:
-    """Removes a linear background from the input data (e.g. the phase background
-    of a spectroscopy).
-
-
-    Parameters
-    ----------
-    data : np.ndarray
-        Input data. Can be a 1D vector or a 2D matrix.
-
-    Returns
-    -------
-    np.ndarray
-        The input data with the linear background removed. The shape of the
-        returned array matches the input `data`.
-    """
-    coefficients = estimate_linear_background(x, data, points_cut)
-
-    # Remove background over the whole array
-    X = np.vstack([np.ones_like(x), x]).T
-    return data - (X @ coefficients).T

sqil_core/utils/const.py

@@ -1,38 +0,0 @@
-EXP_UNIT_MAP = {
-    -15: "p",
-    -12: "f",
-    -9: "n",
-    -6: "\mu",
-    -3: "m",
-    0: "",
-    3: "k",
-    6: "M",
-    9: "G",
-    12: "T",
-    15: "P",
-}
-
-PARAM_METADATA = {
-    "current": {"name": "Current", "symbol": "I", "unit": "A", "scale": 1e3},
-    "ro_freq": {
-        "name": "Readout frequency",
-        "symbol": "f_{RO}",
-        "unit": "Hz",
-        "scale": 1e-9,
-    },
-    "ro_power": {
-        "name": "Readout power",
-        "symbol": "P_{RO}",
-        "unit": "dBm",
-        "scale": 1,
-    },
-    "qu_freq": {
-        "name": "Qubit frequency",
-        "symbol": "f_q",
-        "unit": "Hz",
-        "scale": 1e-9,
-    },
-    "qu_power": {"name": "Qubit power", "symbol": "P_q", "unit": "dBm", "scale": 1},
-    "vna_bw": {"name": "VNA bandwidth", "symbol": "BW_{VNA}", "unit": "Hz", "scale": 1},
-    "vna_avg": {"name": "VNA averages", "symbol": "avg_{VNA}", "unit": "", "scale": 1},
-}