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

sqil_core/utils/formatter.py

@@ -1,134 +0,0 @@
-from decimal import ROUND_DOWN, Decimal
-
-import numpy as np
-
-from .const import EXP_UNIT_MAP, PARAM_METADATA
-from .read import read_json
-
-
-def _cut_to_significant_digits(number, n):
-    """Cut a number to n significant digits."""
-    if number == 0:
-        return 0  # Zero has no significant digits
-    d = Decimal(str(number))
-    shift = d.adjusted()  # Get the exponent of the number
-    rounded = d.scaleb(-shift).quantize(
-        Decimal("1e-{0}".format(n - 1)), rounding=ROUND_DOWN
-    )
-    return float(rounded.scaleb(shift))
-
-
-def format_number(
-    num: float | np.ndarray, precision: int = 3, unit: str = "", latex: bool = True
-) -> str:
-    """Format a number (or an array of numbers) in a nice way for printing.
-
-    Parameters
-    ----------
-    num : float | np.ndarray
-        Input number (or array). Should not be rescaled,
-        e.g. input values in Hz, NOT GHz
-    precision : int
-        The number of digits of the output number. Must be >= 3.
-    unit : str, optional
-        Unit of measurement, by default ''
-    latex : bool, optional
-        Include Latex syntax, by default True
-
-    Returns
-    -------
-    str
-        Formatted number
-    """
-    # Handle arrays
-    if isinstance(num, (list, np.ndarray)):
-        return [format_number(n, unit, latex) for n in num]
-
-    # Return if not a number
-    if not isinstance(num, (int, float, complex)):
-        return num
-
-    # Format number
-    exp_form = f"{num:.12e}"
-    base, exponent = exp_form.split("e")
-    # Make exponent a multiple of 3
-    base = float(base) * 10 ** (int(exponent) % 3)
-    exponent = (int(exponent) // 3) * 3
-    # Apply precision to the base
-    if precision < 3:
-        precision = 3
-    base_precise = _cut_to_significant_digits(
-        base, precision + 1
-    )  # np.round(base, precision - (int(exponent) % 3))
-    base_precise = np.round(
-        base_precise, precision - len(str(base_precise).split(".")[0])
-    )
-    if int(base_precise) == float(base_precise):
-        base_precise = int(base_precise)
-
-    # Build string
-    if unit:
-        res = f"{base_precise}{'~' if latex else ' '}{EXP_UNIT_MAP[exponent]}{unit}"
-    else:
-        res = f"{base_precise}" + (f" x 10^{{{exponent}}}" if exponent != 0 else "")
-    return f"${res}$" if latex else res
-
-
-def get_name_and_unit(param_id: str) -> str:
-    """Get the name and unit of measurement of a prameter, e.g. Frequency [GHz].
-
-    Parameters
-    ----------
-    param : str
-        Parameter ID, as defined in the param_dict.json file.
-
-    Returns
-    -------
-    str
-        Name and [unit]
-    """
-    meta = PARAM_METADATA[param_id]
-    scale = meta["scale"] if "scale" in meta else 1
-    exponent = -(int(f"{scale:.0e}".split("e")[1]) // 3) * 3
-    return f"{meta['name']} [{EXP_UNIT_MAP[exponent]}{meta['unit']}]"
-
-
-def get_x_id_by_plot_dim(exp_id: str, plot_dim: str, sweep_param: str | None) -> str:
-    if exp_id == "CW_onetone":
-        if plot_dim == "1":
-            return sweep_param or "ro_freq"
-        return "ro_freq"
-
-
-def build_title(title: str, path: str, params: list[str]) -> str:
-    """Build a plot title that includes the values of given parameters found in
-    the params_dict.json file, e.g. One tone with I = 0.5 mA.
-
-    Parameters
-    ----------
-    title : str
-        Title of the plot to which the parameters will be appended.
-
-    path: str
-        Path to the param_dict.json file.
-
-    params : List[str]
-        List of keys of parameters in the param_dict.json file.
-
-    Returns
-    -------
-    str
-        The original title followed by parameter values.
-    """
-    dic = read_json(f"{path}/param_dict.json")
-    title += " with "
-    for idx, param in enumerate(params):
-        if not (param in PARAM_METADATA.keys()) or not (param in dic):
-            title += f"{param} = ? & "
-            continue
-        meta = PARAM_METADATA[param]
-        value = format_number(dic[param], meta["unit"])
-        title += f"${meta['symbol']} =${value} & "
-        if idx % 2 == 0 and idx != 0:
-            title += "\n"
-    return title[0:-3]

sqil_core/utils/read.py

@@ -1,156 +0,0 @@
-import json
-import os
-
-import h5py
-import numpy as np
-
-from .const import PARAM_METADATA
-
-
-def extract_h5_data(
-    path: str, keys: list[str] | None = None
-) -> 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()
-        # 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][:]))
-            return tuple(res)
-        # Extract the whole data dictionary
-        return _h5_to_dict(data)
-
-
-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 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
-
-
-class ParamInfo:
-    """Parameter information for items of param_dict
-
-    Attributes:
-        id (str): param_dict key
-        value (any): the value of the parameter
-        name (str): full name of the parameter (e.g. Readout frequency)
-        symbol (str): symbol of the parameter in Latex notation (e.g. f_{RO})
-        unit (str): base unit of measurement (e.g. Hz)
-        scale (int): the scale that should be generally applied to raw data (e.g. 1e-9 to take raw Hz to GHz)
-    """
-
-    def __init__(self, id, value):
-        self.id = id
-        self.value = value
-        if id in PARAM_METADATA:
-            meta = PARAM_METADATA[id]
-        else:
-            meta = {}
-        self.name = meta["name"] if "name" in meta else id
-        self.symbol = meta["symbol"] if "symbol" in meta else id
-        self.unit = meta["unit"] if "unit" in meta else ""
-        self.scale = meta["scale"] if "scale" in meta else 1
-
-    def to_dict(self):
-        """Convert ParamInfo to a dictionary."""
-        return {
-            "id": self.id,
-            "value": self.value,
-            "name": self.name,
-            "symbol": self.symbol,
-            "unit": self.unit,
-            "scale": self.scale,
-        }
-
-    def __str__(self):
-        """Return a JSON-formatted string of the object."""
-        return json.dumps(self.to_dict())
-
-    def __eq__(self, other):
-        if isinstance(other, ParamInfo):
-            return (self.id == other.id) & (self.value == other.value)
-        if isinstance(other, (int, float, complex, str)):
-            return self.value == other
-        return False
-
-
-ParamDict = dict[str, ParamInfo | dict[str, ParamInfo]]
-
-
-def _enrich_param_dict(param_dict: dict) -> ParamDict:
-    """Add metadata to param_dict entries."""
-    res = {}
-    for key, value in param_dict.items():
-        if isinstance(value, dict):
-            # Recursive step for nested dictionaries
-            res[key] = _enrich_param_dict(value)
-        else:
-            res[key] = ParamInfo(key, value)
-    return res
-
-
-def read_param_dict(path: str) -> ParamDict:
-    """Read param_dict and include additional information for each entry.
-
-    Parameters
-    ----------
-    path : str
-        Path to the file or a folder in which is contained a param_dict.json file
-
-    Returns
-    -------
-    ParamDict
-        The param_dict with additional metadata
-    """
-    # If the path is to a folder open /param_dict.json
-    if os.path.isdir(path):
-        path = os.path.join(path, "param_dict.json")
-    return _enrich_param_dict(read_json(path))

sqil_core-0.0.2.dist-info/RECORD

@@ -1,10 +0,0 @@
-sqil_core/__init__.py,sha256=JzMIz-0dEtF2rpf7ZBoIG4Ypd-0R4Xt87E8UKk6Was4,105
-sqil_core/utils/__init__.py,sha256=KzCQaJ11jGja82QXC7lHI1MYKi4Gxz_qwxCr8oTxK3k,156
-sqil_core/utils/analysis.py,sha256=CrtZ06KlNq-CcROoJiKgQWtUV9xnN3Ppv7QsUGFAY08,2106
-sqil_core/utils/const.py,sha256=gfZL9MOzAxJ0BeKMxIelVN3yY0dG-Px9W5fwGiZRYfw,953
-sqil_core/utils/formatter.py,sha256=VyYY2qGhWnt6TU3dOcwGpPUsNqMt-0TIZdzw3CnyCh4,4190
-sqil_core/utils/read.py,sha256=BSbv-audrnILJceCMOTr8KWsjza-4OypGBiV1FVY4yM,4963
-sqil_core-0.0.2.dist-info/METADATA,sha256=Zz1mChc4jhii-k8TLfS_oLlLTTDWyxUOLIh8w7_wp5s,2434
-sqil_core-0.0.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-sqil_core-0.0.2.dist-info/entry_points.txt,sha256=2IYIJomhGZYKEZRBeCuH07ng82_2RzvrZOfhmBdhYxY,99
-sqil_core-0.0.2.dist-info/RECORD,,