qubitclient 0.0.0.1__py3-none-any.whl → 0.0.1__py3-none-any.whl

qubitclient/scope/scope_api/models/body_t1_fit_api_v1_tasks_scope_t1_fit_post.py

@@ -0,0 +1,83 @@
+from collections.abc import Mapping
+from io import BytesIO
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from .. import types
+from ..types import File
+
+T = TypeVar("T", bound="BodyT1FitApiV1TasksScopeT1FitPost")
+
+
+@_attrs_define
+class BodyT1FitApiV1TasksScopeT1FitPost:
+    """
+    Attributes:
+        files (list[File]):
+    """
+
+    files: list[File]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        files = []
+        for files_item_data in self.files:
+            files_item = files_item_data.to_tuple()
+
+            files.append(files_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "files": files,
+            }
+        )
+
+        return field_dict
+
+    def to_multipart(self) -> types.RequestFiles:
+        files: types.RequestFiles = []
+
+        for files_item_element in self.files:
+            files.append(("files", files_item_element.to_tuple()))
+
+        for prop_name, prop in self.additional_properties.items():
+            files.append((prop_name, (None, str(prop).encode(), "text/plain")))
+
+        return files
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        files = []
+        _files = d.pop("files")
+        for files_item_data in _files:
+            files_item = File(payload=BytesIO(files_item_data))
+
+            files.append(files_item)
+
+        body_t1_fit_api_v1_tasks_scope_t1_fit_post = cls(
+            files=files,
+        )
+
+        body_t1_fit_api_v1_tasks_scope_t1_fit_post.additional_properties = d
+        return body_t1_fit_api_v1_tasks_scope_t1_fit_post
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

qubitclient/scope/scope_api/models/body_t1_fit_api_v1_tasks_scope_t2_fit_post.py

@@ -0,0 +1,83 @@
+from collections.abc import Mapping
+from io import BytesIO
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from .. import types
+from ..types import File
+
+T = TypeVar("T", bound="BodyT1FitApiV1TasksScopeT2FitPost")
+
+
+@_attrs_define
+class BodyT1FitApiV1TasksScopeT2FitPost:
+    """
+    Attributes:
+        files (list[File]):
+    """
+
+    files: list[File]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        files = []
+        for files_item_data in self.files:
+            files_item = files_item_data.to_tuple()
+
+            files.append(files_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "files": files,
+            }
+        )
+
+        return field_dict
+
+    def to_multipart(self) -> types.RequestFiles:
+        files: types.RequestFiles = []
+
+        for files_item_element in self.files:
+            files.append(("files", files_item_element.to_tuple()))
+
+        for prop_name, prop in self.additional_properties.items():
+            files.append((prop_name, (None, str(prop).encode(), "text/plain")))
+
+        return files
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        files = []
+        _files = d.pop("files")
+        for files_item_data in _files:
+            files_item = File(payload=BytesIO(files_item_data))
+
+            files.append(files_item)
+
+        body_t1_fit_api_v1_tasks_scope_t2_fit_post = cls(
+            files=files,
+        )
+
+        body_t1_fit_api_v1_tasks_scope_t2_fit_post.additional_properties = d
+        return body_t1_fit_api_v1_tasks_scope_t2_fit_post
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

qubitclient/scope/scope_api/models/http_validation_error.py

@@ -0,0 +1,75 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.validation_error import ValidationError
+
+
+T = TypeVar("T", bound="HTTPValidationError")
+
+
+@_attrs_define
+class HTTPValidationError:
+    """
+    Attributes:
+        detail (Union[Unset, list['ValidationError']]):
+    """
+
+    detail: Union[Unset, list["ValidationError"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        detail: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.detail, Unset):
+            detail = []
+            for detail_item_data in self.detail:
+                detail_item = detail_item_data.to_dict()
+                detail.append(detail_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.validation_error import ValidationError
+
+        d = dict(src_dict)
+        detail = []
+        _detail = d.pop("detail", UNSET)
+        for detail_item_data in _detail or []:
+            detail_item = ValidationError.from_dict(detail_item_data)
+
+            detail.append(detail_item)
+
+        http_validation_error = cls(
+            detail=detail,
+        )
+
+        http_validation_error.additional_properties = d
+        return http_validation_error
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

qubitclient/scope/scope_api/models/validation_error.py

@@ -0,0 +1,88 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ValidationError")
+
+
+@_attrs_define
+class ValidationError:
+    """
+    Attributes:
+        loc (list[Union[int, str]]):
+        msg (str):
+        type_ (str):
+    """
+
+    loc: list[Union[int, str]]
+    msg: str
+    type_: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        loc = []
+        for loc_item_data in self.loc:
+            loc_item: Union[int, str]
+            loc_item = loc_item_data
+            loc.append(loc_item)
+
+        msg = self.msg
+
+        type_ = self.type_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "loc": loc,
+                "msg": msg,
+                "type": type_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        loc = []
+        _loc = d.pop("loc")
+        for loc_item_data in _loc:
+
+            def _parse_loc_item(data: object) -> Union[int, str]:
+                return cast(Union[int, str], data)
+
+            loc_item = _parse_loc_item(loc_item_data)
+
+            loc.append(loc_item)
+
+        msg = d.pop("msg")
+
+        type_ = d.pop("type")
+
+        validation_error = cls(
+            loc=loc,
+            msg=msg,
+            type_=type_,
+        )
+
+        validation_error.additional_properties = d
+        return validation_error
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

qubitclient/scope/scope_api/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

qubitclient/scope/scope_api/types.py

@@ -0,0 +1,54 @@
+"""Contains some shared types for properties"""
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import IO, BinaryIO, Generic, Literal, Optional, TypeVar, Union
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = Union[IO[bytes], bytes, str]
+FileTypes = Union[
+    # (filename, file (or bytes), content_type)
+    tuple[Optional[str], FileContent, Optional[str]],
+    # (filename, file (or bytes), content_type, headers)
+    tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
+]
+RequestFiles = list[tuple[str, FileTypes]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+
+    def to_tuple(self) -> FileTypes:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: Optional[T]
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]

qubitclient/scope/task.py

@@ -0,0 +1,140 @@
+
+
+from .scope_api.api.defined_tasks import s21peak_api_v1_tasks_scope_s21peak_post
+from .scope_api.api.defined_tasks import optpipulse_api_v1_tasks_scope_optpipulse_post
+from .scope_api.api.defined_tasks import rabi_api_v1_tasks_scope_rabi_post
+from .scope_api.api.defined_tasks import rabicos_api_v1_tasks_scope_rabicospeak_post
+from .scope_api.api.defined_tasks import s21vflux_api_v1_tasks_scope_s21vflux_post
+from .scope_api.api.defined_tasks import singleshot_api_v1_tasks_scope_singleshot_post
+from .scope_api.api.defined_tasks import spectrum_api_v1_tasks_scope_spectrum_post
+from .scope_api.api.defined_tasks import t1fit_api_v1_tasks_scope_t1fit_post
+from .scope_api.api.defined_tasks import t1fit_api_v1_tasks_scope_t2fit_post
+
+from .scope_api.models import BodyS21PeakApiV1TasksScopeS21PeakPost
+from .scope_api.models import BodyOptpipulseApiV1TasksScopeOptpipulsePost
+from .scope_api.models import BodyRabiApiV1TasksScopeRabiPost
+from .scope_api.models import BodyRabicosApiV1TasksScopeRabicospeakPost
+from .scope_api.models import BodyS21VfluxApiV1TasksScopeS21VfluxPost
+from .scope_api.models import BodySingleshotApiV1TasksScopeSingleshotPost
+from .scope_api.models import BodySpectrumApiV1TasksScopeSpectrumPost
+from .scope_api.models import BodyT1FitApiV1TasksScopeT1FitPost
+from .scope_api.models import BodyT1FitApiV1TasksScopeT2FitPost
+
+from .scope_api.types import Response
+from .scope_api.types import File
+
+import io
+import numpy as np
+def load_from_dict(dict_list: list[dict]):
+    files = []
+    for index, dict_obj in enumerate(dict_list):
+        with io.BytesIO() as buffer:
+            np.savez(buffer, **dict_obj)
+            bytes_obj = buffer.getvalue()
+            # 假设File类定义如下：
+            # File(payload=bytes内容, file_name=字符串)
+            files.append(File(payload=bytes_obj, file_name=f"file_{index}.npz"))
+    return files
+
+def load_from_ndarray(ndarray_list: list[np.ndarray]):
+    files = []
+    for idx, ndarray_data in enumerate(ndarray_list):
+        buffer = io.BytesIO()
+        np.save(buffer, ndarray_data)
+        buffer.seek(0)
+        files.append(File(payload=buffer.read(), file_name=f"file_{idx}.npz"))
+    return files
+
+def load_from_path(filepath_list: list[str]):
+    files = []
+    for file_path in filepath_list:
+        with open(file_path, "rb") as f:
+            file_content = f.read()
+            files.append(File(payload=file_content, file_name=file_path))
+    return files
+def load_files(filepath_list: list[str|dict[str,np.ndarray]|np.ndarray]):
+    if len(filepath_list)<=0:
+        return []
+    else:
+        if isinstance(filepath_list[0], dict):
+            return load_from_dict(filepath_list)
+        elif isinstance(filepath_list[0], np.ndarray):
+            return load_from_ndarray(filepath_list)
+        elif isinstance(filepath_list[0], str):
+            return load_from_path(filepath_list)
+        
+DEFINED_TASKS = {}
+def task_register(func):
+    DEFINED_TASKS[func.__name__.lower()] = func
+    return func
+
+def run_task(client,file_list: list[str|dict[str,np.ndarray]|np.ndarray],task_type:str):
+    files = load_files(file_list)
+    response = DEFINED_TASKS[task_type.value](client,files)
+    return response
+
+
+@task_register
+def s21peak(client,files: File):
+    body: BodyS21PeakApiV1TasksScopeS21PeakPost = BodyS21PeakApiV1TasksScopeS21PeakPost(files=files)
+    response: Response[BodyS21PeakApiV1TasksScopeS21PeakPost] = s21peak_api_v1_tasks_scope_s21peak_post.sync_detailed(client=client,body=body)
+    return response
+@task_register
+def optpipulse(client,files: File):
+    body: BodyOptpipulseApiV1TasksScopeOptpipulsePost = BodyOptpipulseApiV1TasksScopeOptpipulsePost(files=files)
+    response: Response[BodyOptpipulseApiV1TasksScopeOptpipulsePost] = optpipulse_api_v1_tasks_scope_optpipulse_post.sync_detailed(client=client,body=body)
+    return response
+@task_register
+def rabi(client,files: File):
+    body: BodyRabiApiV1TasksScopeRabiPost = BodyRabiApiV1TasksScopeRabiPost(files=files)
+    response: Response[BodyRabiApiV1TasksScopeRabiPost] = rabi_api_v1_tasks_scope_rabi_post.sync_detailed(client=client,body=body)
+    return response
+@task_register
+def rabicos(client,files: File):
+    body: BodyRabicosApiV1TasksScopeRabicospeakPost = BodyRabicosApiV1TasksScopeRabicospeakPost(files=files)
+    response: Response[BodyRabicosApiV1TasksScopeRabicospeakPost] = rabicos_api_v1_tasks_scope_rabicospeak_post.sync_detailed(client=client,body=body)
+    return response
+@task_register
+def s21vflux(client,files: File):
+    body: BodyS21VfluxApiV1TasksScopeS21VfluxPost = BodyS21VfluxApiV1TasksScopeS21VfluxPost(files=files)
+    response: Response[BodyS21VfluxApiV1TasksScopeS21VfluxPost] = s21vflux_api_v1_tasks_scope_s21vflux_post.sync_detailed(client=client,body=body)
+    return response
+@task_register
+def singleshot(client,files: File):
+    body: BodySingleshotApiV1TasksScopeSingleshotPost = BodySingleshotApiV1TasksScopeSingleshotPost(files=files)
+    response: Response[BodySingleshotApiV1TasksScopeSingleshotPost] = singleshot_api_v1_tasks_scope_singleshot_post.sync_detailed(client=client,body=body)
+    return response
+@task_register
+def spectrum(client,files: File):
+    body: BodySpectrumApiV1TasksScopeSpectrumPost = BodySpectrumApiV1TasksScopeSpectrumPost(files=files)
+    response: Response[BodySpectrumApiV1TasksScopeSpectrumPost] = spectrum_api_v1_tasks_scope_spectrum_post.sync_detailed(client=client,body=body)
+    return response
+@task_register
+def t1fit(client,files: File):
+    body: BodyT1FitApiV1TasksScopeT1FitPost = BodyT1FitApiV1TasksScopeT1FitPost(files=files)
+    response: Response[BodyT1FitApiV1TasksScopeT1FitPost] = t1fit_api_v1_tasks_scope_t1fit_post.sync_detailed(client=client,body=body)
+    return response
+@task_register
+def t2fit(client,files: File):
+    body: BodyT1FitApiV1TasksScopeT2FitPost = BodyT1FitApiV1TasksScopeT2FitPost(files=files)
+    response: Response[BodyT1FitApiV1TasksScopeT2FitPost] = t1fit_api_v1_tasks_scope_t2fit_post.sync_detailed(client=client,body=body)
+    return response
+
+
+
+from enum import Enum, unique
+@unique
+class TaskName(Enum):
+    S21PEAK = "s21peak"
+    OPTPIPULSE = "optpipulse"
+    RABI = "rabi"
+    RABICOS = "rabicos"
+    S21VFLUX = "s21vflux"
+    SINGLESHOT = "singleshot"
+    SPECTRUM = "spectrum"
+    T1FIT = "t1fit"
+    T2FIT = "t2fit"
+
+
+
+

qubitclient/scope/utils/data_parser.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2025 yaqiang.sun.
+# This source code is licensed under the license found in the LICENSE file
+# in the root directory of this source tree.
+#########################################################################
+# Author: yaqiangsun
+# Created Time: 2025/04/11 17:58:29
+########################################################################
+
+import os
+import numpy as np
+import cv2
+
+
+def load_npy_file(file_path):
+    try:
+        array = np.load(file_path, allow_pickle=True)
+        return array
+    except Exception as e:
+        raise ValueError(f"加载文件 {file_path} 时出错: {str(e)}")

qubitclient/utils/data_convert.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2025 yaqiang.sun.
+# This source code is licensed under the license found in the LICENSE file
+# in the root directory of this source tree.
+#########################################################################
+# Author: yaqiangsun
+# Created Time: 2025/10/24 15:54:07
+########################################################################
+
+
+import numpy as np
+import io
+import os
+import numpy as np
+import cv2
+
+
+def load_npz_file(file_path):
+    with np.load(file_path, allow_pickle=True) as data:  # 修改：添加 allow_pickle=True 参数
+        # file_contents[file_name] = dict(data)  # 将 .npz 文件内容转换为字典
+        content = dict(data)  # 将 .npz 文件内容转换为字典
+    return content
+def convert_data_to_image(npz_content):
+    content = npz_content
+    iq_avg = content["iq_avg"]  # 二维数据
+    iq_avg_normalized = convert_complex_map__to_image(iq_avg=iq_avg)
+    return iq_avg_normalized
+def convert_complex_map__to_image(iq_avg):
+    # 检查并转置
+    rows, cols = iq_avg.shape
+    if rows < cols:
+        iq_avg = iq_avg.T  # 转置矩阵
+
+
+    # 取相位
+    phase = np.angle(iq_avg)
+    phase_normalized = ((phase + np.pi) / (2 * np.pi)) * 255
+    # 纵向归一化
+    phase_mean = phase_normalized.mean(axis=0, keepdims=True)   # 形状(1,30)
+    ppase_std = phase_normalized.std(axis=0, keepdims=True)     # 形状(1,30)
+    phase_normalized = (phase_normalized - phase_mean) / (ppase_std+1e-8)
+    # phase_normalized = phase_normalized.astype(np.uint8)
+    # 全局归一化
+    phase_normalized = cv2.normalize(phase_normalized, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
+
+    # 取幅度
+    iq_avg = np.abs(iq_avg)
+    
+    # iq_avg = phase_normalized
+    # 纵向归一化
+    # mean = iq_avg.mean(axis=0, keepdims=True)   # 形状(1,30)
+    # std = iq_avg.std(axis=0, keepdims=True)     # 形状(1,30)
+    # iq_avg = (iq_avg - mean) / (std+1e-8)
+    # 幅度全局归一化
+    iq_avg_normalized = cv2.normalize(iq_avg, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
+    # return iq_avg_normalized
+
+    #取幅度的梯度
+    gradient_y, gradient_x = np.gradient(iq_avg)
+    gradient_y = np.abs(gradient_y)
+    gradient_y_normalized = cv2.normalize(gradient_y, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
+    
+    # iq_avg_normalized = cv2.merge([iq_avg_normalized, phase_normalized, gradient_y_normalized])
+    iq_avg_normalized = cv2.merge([iq_avg_normalized, iq_avg_normalized, iq_avg_normalized])
+    return iq_avg_normalized
+
+    
+def load_npz_to_image(file_path):
+    npz_content = load_npz_file(file_path)
+    image = convert_data_to_image(npz_content)
+    return image
+
+def convert_spectrum_npy2npz(npy_file_path:str):
+    data = np.load(npy_file_path, allow_pickle=True)
+    data = data.item() if isinstance(data, np.ndarray) else data
+    dict_list, name_list = convert_spectrum_dict2npz(data)
+    return dict_list, name_list
+def convert_spectrum_dict2npz(data:dict):
+    if not isinstance(data, dict) or 'image' not in data:
+            raise ValueError("数据格式无效，缺少 'image' 键")
+    image = data["image"]
+    q_list = image.keys()
+
+    dict_list = []
+    name_list = []
+
+    for idx, q_name in enumerate(q_list):
+        image_q = image[q_name]
+
+        data = image_q[0]
+        data = np.array(data)
+        data = np.abs(data)
+        height_axis = image_q[1]
+        width_axis = image_q[2]
+        new_dict = {}
+        new_dict["iq_avg"] = data
+        new_dict["frequency"] = image_q[2]
+        new_dict["bias"] = image_q[1]
+
+        npz_file_path = npy_file_path.replace(".npy", f"{q_name}.npz")
+        dict_list.append(new_dict)
+        name_list.append(npz_file_path)
+        # npz_file_path = npz_file_path.replace("npyfile","npyconverted")
+        # np.savez(npz_file_path,**new_dict)
+        # np.savez(npz_file_path,iq_avg=image_q[0],frequency=image_q[2],bias=image_q[1])
+    return dict_list, name_list
+
+if __name__ == '__main__':
+    npy_file_path = "tmp/npyfile/tmp0ffc025b.py_4905.npy"
+    convert_spectrum_npy2npz(npy_file_path)
+
+    image = load_npz_to_image("tmp/npyconverted/tmp0ffc025b.py_4905Q6.npz")