qubitclient 0.1.4__py3-none-any.whl

qubitclient/nnscope/task.py

@@ -0,0 +1,170 @@
+
+import os
+import requests
+
+import io
+import numpy as np
+
+
+from qubitclient.nnscope.utils.data_convert import convert_spectrum_npy2npz,convert_spectrum_dict2npz
+
+# load from npz file path
+def load_from_npz_path(file_path_list:list[str]):
+    files = []
+    npydata = {}
+    npydata['id'] = 0
+    image_qs = {}
+    index = 0
+    for file_path in file_path_list:
+        if file_path.endswith('.npz'):
+            index+=1
+            with np.load(file_path, allow_pickle=True) as data:  # 修改：添加 allow_pickle=True 参数
+                # file_contents[file_name] = dict(data)  # 将 .npz 文件内容转换为字典
+                content = dict(data)  # 将 .npz 文件内容转换为字典
+                image_qs[str(index)] = (content['iq_avg'],content['bias'],content['frequency'])
+    npydata['image'] = image_qs
+    with io.BytesIO() as buffer:
+        np.save(buffer, npydata)
+        bytes_obj = buffer.getvalue()
+    files.append(("request", ("None.npy", bytes_obj, "application/octet-stream")))
+    return files
+# def load_from_npz_path(file_path_list:list[str]):
+#     files = []
+#     npydata = {}
+#     npydata['id'] = 0
+#     index = 0
+#     for file_path in file_path_list:
+#         if file_path.endswith('.npz'):
+#             index+=1
+#             with np.load(file_path, allow_pickle=True) as data:  # 修改：添加 allow_pickle=True 参数
+#                 # file_contents[file_name] = dict(data)  # 将 .npz 文件内容转换为字典
+#                 content = dict(data)  # 将 .npz 文件内容转换为字典
+#                 allq = content['image'].item()
+#                 allq_downsample={}
+#                 for q in allq.keys():
+#                     singleq = allq[q]
+#                     singleq_downsampe = (singleq[0][::1,::1],singleq[1][::1],singleq[2][::1])
+#                     # iq = zoom(singleq[0],(2,1),order=1)
+#                     # zero_arr = np.zeros((45,40))
+#                     # iq = np.vstack((singleq[0],zero_arr))
+#                     # # iq = np.vstack((singleq[0],singleq[0]))
+#                     #
+#                     # arr_2d = singleq[2].reshape(1,-1)
+#                     # arr_zoomed = zoom(arr_2d,(1,2),order=1)
+#                     # freq = arr_zoomed.flatten()
+#                     #
+#                     #
+#                     # singleq_downsampe = (iq[::1,::1],singleq[1][::1],freq)
+#
+#
+#                     # singleq_downsampe = (singleq[0],singleq[1],singleq[2])
+#
+#                     allq_downsample[q] = singleq_downsampe
+#                 # allq_downsample  = np.array(allq_downsample,dtype=object).reshape(())
+#                 # npydata['image'] = (content['image'])
+#                 npydata['image'] = allq_downsample
+#     with io.BytesIO() as buffer:
+#         np.save(buffer, npydata)
+#         bytes_obj = buffer.getvalue()
+#     files.append(("request", ("None.npy", bytes_obj, "application/octet-stream")))
+#     return files
+def load_from_npy_path(file_path_list:list[str]):
+    files = []
+    for file_path in file_path_list:
+        if file_path.endswith('.npy'):
+            data = np.load(file_path, allow_pickle=True)
+            data = data.item() if isinstance(data, np.ndarray) else data
+            with io.BytesIO() as buffer:
+                np.save(buffer, data)
+                bytes_obj = buffer.getvalue()
+            files.append(("request", ("None.npy", bytes_obj, "application/octet-stream")))
+    return files
+def load_from_npz_dict(dict_list:list[dict]):
+    files = []
+    npydata = {}
+    npydata['id'] = 0
+    image_qs = {}
+    for index,dict_obj in enumerate(dict_list):
+        image_qs[str(index)] = (dict_obj['iq_avg'], dict_obj['bias'], dict_obj['frequency'])
+    npydata['image'] = image_qs
+    with io.BytesIO() as buffer:
+        np.save(buffer, npydata)
+        bytes_obj = buffer.getvalue()
+    files.append(("request", ("None.npy", bytes_obj, "application/octet-stream")))
+    return files
+def load_from_npy_dict(dict_list:list[dict]):
+    files = []
+    for dict_obj in dict_list:
+        with io.BytesIO() as buffer:
+            np.save(buffer, dict_obj)
+            bytes_obj = buffer.getvalue()
+        files.append(("request", ("None.npy",bytes_obj, "application/octet-stream")))
+    return files
+def request_task(files,url,api_key,curve_type:str=None):
+    headers = {'Authorization': f'Bearer {api_key}'}  # 添加API密钥到请求头
+    data = {
+            "curve_type":curve_type.value if curve_type else None
+    }
+    response = requests.post(url, files=files, headers=headers,data=data)
+    return response
+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):
+            if "image" in filepath_list[0]:
+                return load_from_npy_dict(filepath_list)
+            else:
+                return load_from_npz_dict(filepath_list)
+        elif isinstance(filepath_list[0], np.ndarray):
+            filepath_list = [filepath_list[i].item() for i in range(len(filepath_list))]
+            return load_files(filepath_list)
+        elif isinstance(filepath_list[0], str):
+            if filepath_list[0].endswith('.npz'):
+                return load_from_npz_path(filepath_list)
+            elif filepath_list[0].endswith('.npy'):
+                return load_from_npy_path(filepath_list)
+            else:
+                return []
+
+
+
+DEFINED_TASKS = {}
+def task_register(func):
+    DEFINED_TASKS[func.__name__.lower()] = func
+    return func
+
+def run_task(file_list: list[str|dict[str,np.ndarray]|np.ndarray],url,api_key,task_type:str,*args,**kwargs):
+    files = load_files(file_list)
+    response = DEFINED_TASKS[task_type.value](files,url,api_key,*args,**kwargs)
+    return response
+
+
+@task_register
+def test(files):
+    
+    return "hello"
+
+@task_register
+def spectrum2d(files,url,api_key,curve_type):
+    spectrum2d_url = url + "/api/v1/tasks/nnscope/seglines"
+    response = request_task(files,spectrum2d_url,api_key,curve_type)
+    return response
+
+from enum import Enum, unique
+@unique
+class NNTaskName(Enum):
+    # S21PEAK = "s21peak"
+    # OPTPIPULSE = "optpipulse"
+    # RABI = "rabi"
+    # RABICOS = "rabicos"
+    # S21VFLUX = "s21vflux"
+    # SINGLESHOT = "singleshot"
+    # SPECTRUM = "spectrum"
+    # T1FIT = "t1fit"
+    # T2FIT = "t2fit"
+    SPECTRUM2D = "spectrum2d"
+
+
+
+

qubitclient/nnscope/utils/data_convert.py

@@ -0,0 +1,114 @@
+# -*- 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,npy_file_path)
+    return dict_list, name_list
+def convert_spectrum_dict2npz(data:dict,npy_file_path:str="None.npy"):
+    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]
+        if data.ndim != 2:
+            raise ValueError("数据格式无效，data不是二维数组")
+        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")

qubitclient/nnscope/utils/data_parser.py

@@ -0,0 +1,41 @@
+# -*- 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_npz_file(file_path):
+    with np.load(file_path, allow_pickle=True) as data:
+        content = dict(data)
+    return content
+def convert_data_to_image(npz_content):
+    content = npz_content
+    iq_avg = content["iq_avg"]
+    rows, cols = iq_avg.shape
+    if rows < cols:
+        iq_avg = iq_avg.T
+    iq_avg = np.abs(iq_avg)
+    iq_avg_normalized = cv2.normalize(iq_avg, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
+    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 load_npz_to_images(file_path_list):
+    images = []
+    for file_path in file_path_list:
+        print(file_path)
+        image = load_npz_to_image(file_path)
+        images.append(image)
+        # cv2.imwrite("tmp/client/test.jpg",image)
+    return images

qubitclient/nnscope/utils/request_tool.py

@@ -0,0 +1,41 @@
+# -*- 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/15 10:31:23
+########################################################################
+import os
+import requests
+import io
+import numpy as np
+from qubitclient.nnscope.nnscope_api.curve.curve_type import CurveType
+
+
+def file_request(file_path_list,url,api_key,curve_type:CurveType=None):
+    files = []
+    for file_path in file_path_list:
+        if file_path.endswith('.npz'):
+            file_name = os.path.basename(file_path)
+            files.append(("request", (file_name, open(file_path, "rb"), "image/jpeg")))
+    headers = {'Authorization': f'Bearer {api_key}'}  # 添加API密钥到请求头
+    data = {
+            "curve_type":curve_type.value if curve_type else None
+    }
+    response = requests.post(url, files=files, headers=headers,data=data)
+    return response
+
+def file_request_with_dict(dict_list,url,api_key,curve_type:str=None):
+    files = []
+    for index,dict_obj in enumerate(dict_list):
+        with io.BytesIO() as buffer:
+            np.savez(buffer, **dict_obj)
+            bytes_obj = buffer.getvalue()
+        files.append(("request", ("None"+str(index)+".npz", bytes_obj, "application/octet-stream")))
+    headers = {'Authorization': f'Bearer {api_key}'}  # 添加API密钥到请求头
+    data = {
+            "curve_type":curve_type.value if curve_type else None
+    }
+    response = requests.post(url, files=files, headers=headers,data=data)
+    return response

qubitclient/nnscope/utils/result_parser.py

@@ -0,0 +1,55 @@
+# -*- 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/15 10:23:27
+########################################################################
+
+import math
+import cv2
+
+def parser_result(result, images):
+    result_images = []
+    for i in range(len(result)):
+        image = images[i]
+        if len(image.shape) == 2:
+            image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+        # input_image_reshape = (512, 512)
+        input_image_reshape = (image.shape[1]*10,image.shape[0])
+        image = cv2.resize(image, input_image_reshape, interpolation=cv2.INTER_NEAREST)
+        
+        
+        image_result = result[i]
+        linepoints_list = image_result["linepoints_list"]
+        for linepoints in linepoints_list:
+            for j in range(len(linepoints) - 1):
+                cv2.line(image, tuple([int(linepoints[j][0]*10),int(linepoints[j][1])]), tuple([int(linepoints[j + 1][0]*10),int(linepoints[j + 1][1])]), (0, 255, 0), 2)
+        
+        # cv2.imwrite(f"tmp/client/result_{i}.jpg", image)
+        result_images.append(image)
+    return result_images
+
+def convet_axis(points,x_dim,y_dim):
+    reflection_points = []
+    for point in points:
+        x = point[0]
+        y = point[1]
+
+        x_grid_start = x_dim[int(x)]
+        x_grid_end = x_dim[min(int(x)+1,len(x_dim)-1)]
+        x_refletion = (x_grid_end-x_grid_start)* math.modf(x)[0] + x_grid_start
+
+        
+        # y_index = min(max(0,int(y)),len(y_dim)-2)
+        y_index = int(y)
+        if y_index<0 or y_index>len(y_dim)-2:
+            continue
+        y_grid_start = y_dim[y_index]
+        y_grid_end = y_dim[y_index+1]
+        y_refletion = (y_grid_end-y_grid_start)* math.modf(y)[0] + y_grid_start
+        reflection_points.append([x_refletion,y_refletion])
+        pass
+        
+    return reflection_points

qubitclient/scope/scope.py

@@ -0,0 +1,50 @@
+# -*- 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/20 18:13:37
+########################################################################
+
+
+import os
+# import cv2
+import numpy as np
+import sys
+# 获取当前文件的绝对路径，向上两层就是项目根目录
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+# 
+# `scope_api_client`: this package is generated by `openapi-python-client`
+from .scope_api import Client, AuthenticatedClient
+from .task import run_task
+import logging
+import numpy as np
+
+
+
+logging.basicConfig(level=logging.INFO)
+
+
+class QubitScopeClient(object):
+    def __init__(self, url, api_key):
+        self.url = url
+        self.api_key = api_key
+        self.client = AuthenticatedClient(base_url=url, token=api_key)
+
+    def request(self, file_list:list[str|dict[str,np.ndarray]],task_type:str="s21peak"):
+        if len(file_list)>0:
+            response = run_task(self.client,file_list,task_type)
+        else:
+            raise ValueError("file_list must not be empty")
+        return response
+    def get_result(self,response):
+        if response.status_code == 200:
+            logging.info("Result: %s", response.parsed)
+            result = response.parsed
+            return result
+        else:
+            logging.error("Error: %s %s", response.status_code, response.parsed)
+            return []

qubitclient/scope/scope_api/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing FastAPI"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

qubitclient/scope/scope_api/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

qubitclient/scope/scope_api/api/defined_tasks/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

qubitclient/scope/scope_api/api/defined_tasks/get_task_result_api_v1_tasks_demo_pk_get.py

@@ -0,0 +1,155 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.http_validation_error import HTTPValidationError
+from ...types import Response
+
+
+def _get_kwargs(
+    pk: int,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/api/v1/tasks/demo/{pk}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, HTTPValidationError]]:
+    if response.status_code == 200:
+        response_200 = response.json()
+        return response_200
+
+    if response.status_code == 422:
+        response_422 = HTTPValidationError.from_dict(response.json())
+
+        return response_422
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, HTTPValidationError]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    pk: int,
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Response[Union[Any, HTTPValidationError]]:
+    """获取任务结果详情
+
+    Args:
+        pk (int): 任务结果 ID
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, HTTPValidationError]]
+    """
+
+    kwargs = _get_kwargs(
+        pk=pk,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    pk: int,
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Optional[Union[Any, HTTPValidationError]]:
+    """获取任务结果详情
+
+    Args:
+        pk (int): 任务结果 ID
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, HTTPValidationError]
+    """
+
+    return sync_detailed(
+        pk=pk,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    pk: int,
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Response[Union[Any, HTTPValidationError]]:
+    """获取任务结果详情
+
+    Args:
+        pk (int): 任务结果 ID
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, HTTPValidationError]]
+    """
+
+    kwargs = _get_kwargs(
+        pk=pk,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    pk: int,
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Optional[Union[Any, HTTPValidationError]]:
+    """获取任务结果详情
+
+    Args:
+        pk (int): 任务结果 ID
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, HTTPValidationError]
+    """
+
+    return (
+        await asyncio_detailed(
+            pk=pk,
+            client=client,
+        )
+    ).parsed