qubitclient 0.1.4__py3-none-any.whl

qubitclient/draw/spectrumpltplotter.py

@@ -0,0 +1,106 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from .pltplotter import QuantumDataPltPlotter
+
+class SpectrumDataPltPlotter(QuantumDataPltPlotter):
+
+    def __init__(self):
+        super().__init__("spectrum")
+
+    def plot_result_npy(self, **kwargs):
+        result = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')
+
+        data = dict_param.item()
+        image = data["image"]
+        q_list = list(image.keys())  # 确保q_list是列表形式，便于索引
+        num_qubits = len(q_list)
+
+        # 数据提取
+        x_list = []
+        amp_list = []
+        q_name_list = []
+
+        for q_name in q_list:
+            image_q = image[q_name]
+            x = image_q[0]  # 假设这里是x轴数据（如频率）
+            amp = image_q[1]  # 假设这里是幅度数据
+            
+            x_list.append(x)
+            amp_list.append(amp)
+            q_name_list.append(q_name)
+
+        # 结果数据
+        peaks_list = result['peaks_list']
+        confidences_list = result['confidences_list']
+
+        max_cols = 5
+        cols = min(num_qubits, max_cols)  # 列数不超过max_cols
+        rows = (num_qubits + cols - 1) // cols  # 计算需要的行数（向上取整）
+
+        fig_width = 6 * cols
+        fig_height = 4 * rows
+        fig, axes = plt.subplots(rows, cols, figsize=(fig_width, fig_height))
+        
+        # 处理单元素或一维数组的axes，统一转为二维数组便于索引
+        if num_qubits == 1:
+            axes = np.array([[axes]])
+        elif rows == 1 or cols == 1:
+            axes = axes.reshape(rows, cols)
+
+        # 为每个 qubit 绘制子图
+        for idx, (x, amp, q_name) in enumerate(zip(x_list, amp_list, q_name_list)):
+            row = idx // cols  # 计算当前子图所在行
+            col = idx % cols   # 计算当前子图所在列
+            ax = axes[row, col]
+
+            # 绘制信号曲线
+            ax.plot(x, amp, label='Signal', color='blue')
+            
+            # 获取当前 qubit 的峰值和置信度
+            peaks = peaks_list[idx] if idx < len(peaks_list) else []
+            confidences = confidences_list[idx] if idx < len(confidences_list) else None
+
+            # 绘制峰值
+            if peaks:
+                if confidences is None:
+                    confidences = [None] * len(peaks)
+                elif len(confidences) != len(peaks):
+                    raise ValueError(f"q_name {q_name} 的peaks和confidences长度不一致")
+                
+                # 计算峰值对应的幅度（找到最接近的x值）
+                peak_amps = [amp[np.argmin(np.abs(x - p))] for p in peaks]
+                ax.scatter(peaks, peak_amps, color='red', s=50, zorder=3, label='Peak')
+                
+                # 添加置信度标注
+                for peak, conf in zip(peaks, confidences):
+                    amp_val = amp[np.argmin(np.abs(x - peak))]
+                    if conf is not None:
+                        ax.annotate(f'conf: {conf:.4f}',
+                                    xy=(peak, amp_val),
+                                    xytext=(5, 5), 
+                                    textcoords='offset points',
+                                    fontsize=8,
+                                    bbox=dict(boxstyle="round,pad=0.3", fc="yellow", alpha=0.5))
+                    else:
+                        ax.annotate(f'{peak:.4f}',
+                                    xy=(peak, amp_val),
+                                    xytext=(5, 5), 
+                                    textcoords='offset points')
+            
+            # 设置子图标题和坐标轴标签
+            ax.set_title(f'Spectrum for {q_name}')
+            ax.set_xlabel('Frequency')
+            ax.set_ylabel('Amplitude')
+            ax.grid(True, linestyle='--', alpha=0.7)
+            ax.legend()
+
+        # 移除多余的子图（当 qubit 数量不足行列乘积时）
+        for idx in range(num_qubits, rows * cols):
+            row = idx // cols
+            col = idx % cols
+            fig.delaxes(axes[row, col])
+
+        # 调整子图间距
+        plt.tight_layout()
+        return fig

qubitclient/draw/spectrumplyplotter.py

@@ -0,0 +1,133 @@
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from .plyplotter import QuantumDataPlyPlotter
+
+class SpectrumDataPlyPlotter(QuantumDataPlyPlotter):
+
+    def __init__(self):
+        super().__init__("spectrum")
+
+    def plot_result_npy(self, **kwargs):
+        result = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')
+
+        data = dict_param.item()
+        image = data["image"]
+        q_list = list(image.keys())  # 确保q_list是列表形式，便于索引
+        num_qubits = len(q_list)
+
+        # 数据提取
+        x_list = []
+        amp_list = []
+        q_name_list = []
+
+        for q_name in q_list:
+            image_q = image[q_name]
+            x = image_q[0]  # 假设这里是x轴数据（如频率）
+            amp = image_q[1]  # 假设这里是幅度数据
+            
+            x_list.append(x)
+            amp_list.append(amp)
+            q_name_list.append(q_name)
+
+        # 结果数据
+        peaks_list = result['peaks_list']
+        confidences_list = result['confidences_list']
+
+        max_cols = 5
+        cols = min(num_qubits, max_cols)  # 列数不超过max_cols
+        rows = (num_qubits + cols - 1) // cols  # 计算需要的行数（向上取整）
+
+        # 创建子图
+        fig = make_subplots(
+            rows=rows,
+            cols=cols,
+            subplot_titles=[f'Spectrum for {q_name}' for q_name in q_name_list],
+            vertical_spacing=0.1,
+            horizontal_spacing=0.05
+        )
+
+        # 为每个 qubit 绘制子图
+        for idx, (x, amp, q_name) in enumerate(zip(x_list, amp_list, q_name_list)):
+            row = (idx // cols) + 1  # Plotly的行列索引从1开始
+            col = (idx % cols) + 1
+
+            # 绘制信号曲线
+            fig.add_trace(
+                go.Scatter(
+                    x=x,
+                    y=amp,
+                    mode='lines',
+                    name='Signal',
+                    line=dict(color='blue'),
+                    showlegend=(idx == 0)  # 只在第一个子图显示图例
+                ),
+                row=row,
+                col=col
+            )
+            
+            # 获取当前 qubit 的峰值和置信度
+            peaks = peaks_list[idx] if idx < len(peaks_list) else []
+            confidences = confidences_list[idx] if idx < len(confidences_list) else None
+
+            # 绘制峰值
+            if peaks:
+                if confidences is None:
+                    confidences = [None] * len(peaks)
+                elif len(confidences) != len(peaks):
+                    raise ValueError(f"q_name {q_name} 的peaks和confidences长度不一致")
+                
+                # 计算峰值对应的幅度（找到最接近的x值）
+                peak_amps = [amp[np.argmin(np.abs(x - p))] for p in peaks]
+                
+                # 添加峰值散点
+                fig.add_trace(
+                    go.Scatter(
+                        x=peaks,
+                        y=peak_amps,
+                        mode='markers',
+                        name='Peak',
+                        marker=dict(color='red', size=8),
+                        showlegend=(idx == 0)  # 只在第一个子图显示图例
+                    ),
+                    row=row,
+                    col=col
+                )
+                
+                # 添加置信度标注
+                for peak, conf, amp_val in zip(peaks, confidences, peak_amps):
+                    annotation_text = f'conf: {conf:.4f}' if conf is not None else f'{peak:.4f}'
+                    fig.add_annotation(
+                        x=peak,
+                        y=amp_val,
+                        text=annotation_text,
+                        xanchor='left',
+                        yanchor='bottom',
+                        showarrow=True,
+                        arrowhead=1,
+                        font=dict(size=8),
+                        bgcolor='yellow',
+                        opacity=0.5,
+                        row=row,
+                        col=col
+                    )
+            
+            # 设置坐标轴标签
+            fig.update_xaxes(title_text='Frequency', row=row, col=col)
+            fig.update_yaxes(title_text='Amplitude', row=row, col=col)
+
+        # 调整布局
+        fig.update_layout(
+            height=400 * rows,  # 每个子图大致400高度
+            width=600 * cols,   # 每个子图大致600宽度
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            )
+        )
+
+        return fig

qubitclient/draw/t1fitpltplotter.py

@@ -0,0 +1,76 @@
+# src/draw/t1fitpltplotter.py
+from .pltplotter import QuantumDataPltPlotter
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class T1FitDataPltPlotter(QuantumDataPltPlotter):
+    def __init__(self):
+        super().__init__("t1fit")
+
+    def plot_result_npy(self, **kwargs):
+        result     = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')      # 唯一原始数据参数
+
+        if not result or not dict_param:
+            fig, ax = plt.subplots()
+            ax.text(0.5, 0.5, "No data", ha='center', transform=ax.transAxes)
+            plt.close(fig)
+            return fig
+
+        data = dict_param.item() if isinstance(dict_param, np.ndarray) else dict_param
+        image_dict = data.get("image", {})
+        qubit_names = list(image_dict.keys())
+        if not qubit_names:
+            fig, ax = plt.subplots()
+            ax.text(0.5, 0.5, "No qubits", ha='center', transform=ax.transAxes)
+            plt.close(fig)
+            return fig
+
+        cols = min(3, len(qubit_names))
+        rows = (len(qubit_names) + cols - 1) // cols
+
+        fig = plt.figure(figsize=(5.8 * cols, 4.5 * rows))
+        fig.suptitle("T1-Fit", fontsize=14, y=0.96)
+
+        params_list   = result.get("params_list", [])
+        r2_list       = result.get("r2_list", [])
+        fit_data_list = result.get("fit_data_list", [])
+
+        for q_idx, q_name in enumerate(qubit_names):
+            ax = fig.add_subplot(rows, cols, q_idx + 1)
+            item = image_dict[q_name]
+            if not isinstance(item, (list, tuple)) or len(item) < 2:
+                continue
+
+            x_raw = np.asarray(item[0])
+            y_raw = np.asarray(item[1])
+
+            # 原始数据点
+            ax.plot(x_raw, y_raw, 'o', color='orange', markersize=4,
+                    label='Data', alpha=0.7)
+
+            # 拟合曲线
+            if q_idx < len(fit_data_list):
+                fit_y = np.asarray(fit_data_list[q_idx])
+                ax.plot(x_raw, fit_y, '-', color='blue', linewidth=2,
+                        label='Fit')
+
+            # 参数文字
+            if q_idx < len(params_list):
+                A, T1, B = params_list[q_idx]
+                r2 = r2_list[q_idx] if q_idx < len(r2_list) else 0.0
+                txt = f"A={A:.3f}\nT1={T1:.1f}µs\nB={B:.3f}\nR²={r2:.3f}"
+                ax.text(0.05, 0.95, txt, transform=ax.transAxes,
+                        verticalalignment='top', fontsize=8,
+                        bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
+
+            ax.set_title(q_name, fontsize=11, pad=10)
+            ax.set_xlabel("Time")
+            ax.set_ylabel("Amp")
+            ax.grid(True, linestyle='--', alpha=0.5)
+            ax.legend(fontsize=8, loc='upper right', framealpha=0.9)
+
+        plt.tight_layout(rect=[0, 0, 1, 0.94])
+        plt.close(fig)
+        return fig

qubitclient/draw/t1fitplyplotter.py

@@ -0,0 +1,109 @@
+# src/draw/t1fitplyplotter.py
+from .plyplotter import QuantumDataPlyPlotter
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import numpy as np
+
+
+class T1FitDataPlyPlotter(QuantumDataPlyPlotter):
+    def __init__(self):
+        super().__init__("t1fit")
+
+    def plot_result_npy(self, **kwargs):
+        result     = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')
+
+        if not result or not dict_param:
+            fig = go.Figure()
+            fig.add_annotation(text="Missing data", xref="paper", yref="paper",
+                               x=0.5, y=0.5, showarrow=False)
+            return fig
+
+        data = dict_param.item() if isinstance(dict_param, np.ndarray) else dict_param
+        image_dict = data.get("image", {})
+        if not image_dict:
+            fig = go.Figure()
+            fig.add_annotation(text="No image data", xref="paper", yref="paper",
+                               x=0.5, y=0.5, showarrow=False)
+            return fig
+
+        qubit_names = list(image_dict.keys())
+        cols = min(3, len(qubit_names))
+        rows = (len(qubit_names) + cols - 1) // cols
+
+        fig = make_subplots(
+            rows=rows, cols=cols,
+            subplot_titles=qubit_names,
+            vertical_spacing=0.08,
+            horizontal_spacing=0.08,
+        )
+
+        params_list   = result.get("params_list", [])
+        r2_list       = result.get("r2_list", [])
+        fit_data_list = result.get("fit_data_list", [])
+
+        data_legend = False
+        fit_legend  = False
+
+        for q_idx, q_name in enumerate(qubit_names):
+            row = q_idx // cols + 1
+            col = q_idx % cols + 1
+
+            item = image_dict[q_name]
+            if not isinstance(item, (list, tuple)) or len(item) < 2:
+                continue
+
+            x_raw = np.asarray(item[0])
+            y_raw = np.asarray(item[1])
+
+            # 原始数据点
+            fig.add_trace(
+                go.Scatter(x=x_raw, y=y_raw, mode='markers',
+                           marker=dict(color='orange', size=6),
+                           name='Data', legendgroup='data',
+                           showlegend=not data_legend),
+                row=row, col=col
+            )
+            if not data_legend:
+                data_legend = True
+
+            # 拟合曲线
+            if q_idx < len(fit_data_list):
+                fit_y = np.asarray(fit_data_list[q_idx])
+                fig.add_trace(
+                    go.Scatter(x=x_raw, y=fit_y, mode='lines',
+                               line=dict(color='blue', width=2),
+                               name='Fit', legendgroup='fit',
+                               showlegend=not fit_legend),
+                    row=row, col=col
+                )
+                if not fit_legend:
+                    fit_legend = True
+
+            # 参数标注
+            if q_idx < len(params_list):
+                A, T1, B = params_list[q_idx]
+                r2 = r2_list[q_idx] if q_idx < len(r2_list) else 0.0
+                txt = f"A={A:.3f}<br>T1={T1:.1f}µs<br>B={B:.3f}<br>R²={r2:.3f}"
+                fig.add_annotation(
+                    x=x_raw[0], y=max(y_raw) * 1.05,
+                    text=txt, showarrow=False,
+                    font=dict(size=9), align="left",
+                    bgcolor="rgba(255,255,255,0.8)", bordercolor="gray",
+                    row=row, col=col
+                )
+
+            if row == rows:
+                fig.update_xaxes(title_text="Time", row=row, col=col)
+            if col == 1:
+                fig.update_yaxes(title_text="Amp", row=row, col=col)
+
+        fig.update_layout(
+            height=420 * rows,
+            width=520 * cols,
+            title_text="T1-Fit",
+            title_x=0.5,
+            legend=dict(font=dict(size=10), bgcolor="rgba(255,255,255,0.8)"),
+            margin=dict(l=60, r=60, t=80, b=60)
+        )
+        return fig

qubitclient/draw/t2fitpltplotter.py

@@ -0,0 +1,70 @@
+# src/draw/t2fitpltplotter.py
+from .pltplotter import QuantumDataPltPlotter
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class T2FitDataPltPlotter(QuantumDataPltPlotter):
+    def __init__(self):
+        super().__init__("t2fit")
+
+    def plot_result_npy(self, **kwargs):
+        result     = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')   # 统一使用 dict_param
+
+        if not result or not dict_param:
+            fig, ax = plt.subplots()
+            ax.text(0.5, 0.5, "No data", ha='center', transform=ax.transAxes)
+            return fig
+
+        data = dict_param.item() if isinstance(dict_param, np.ndarray) else dict_param
+        image_dict = data.get("image", {})
+        qubit_names = list(image_dict.keys())
+        n_qubits = len(qubit_names)
+        cols = min(3, n_qubits)
+        rows = (n_qubits + cols - 1) // cols
+
+        fig = plt.figure(figsize=(5.8 * cols, 4.8 * rows))
+        fig.suptitle("T2 Ramsey / Echo Fit", fontsize=14, y=0.96)
+
+        params_list   = result.get("params_list", [])
+        r2_list       = result.get("r2_list", [])
+        fit_data_list = result.get("fit_data_list", [])
+
+        for q_idx, q_name in enumerate(qubit_names):
+            ax = fig.add_subplot(rows, cols, q_idx + 1)
+            item = image_dict[q_name]
+            if not isinstance(item, (list, tuple)) or len(item) < 2:
+                continue
+
+            x_raw = np.asarray(item[0])
+            y_raw = np.asarray(item[1])
+
+            ax.plot(x_raw, y_raw, 'o', color='orange', markersize=5, label='Data', alpha=0.8)
+
+            if q_idx < len(fit_data_list):
+                y_fit = np.asarray(fit_data_list[q_idx])
+                if len(y_fit) != len(x_raw):
+                    x_fit = np.linspace(x_raw.min(), x_raw.max(), len(y_fit))
+                else:
+                    x_fit = x_raw
+                ax.plot(x_fit, y_fit, '-', color='blue', linewidth=2.2, label='Fit')
+
+            if q_idx < len(params_list):
+                A, B, T1, T2, w, phi = params_list[q_idx]
+                r2 = r2_list[q_idx] if q_idx < len(r2_list) else 0.0
+                text = (f"A={A:.3f}\nB={B:.3f}\nT1={T1:.1f}µs\n"
+                        f"T2={T2:.1f}µs\nω={w/1e6:.2f}MHz\nφ={phi:.3f}\nR²={r2:.4f}")
+                ax.text(0.04, 0.96, text, transform=ax.transAxes,
+                        verticalalignment='top', fontsize=8,
+                        bbox=dict(boxstyle="round,pad=0.4", facecolor="white", alpha=0.9))
+
+            ax.set_title(q_name, fontsize=11, pad=10)
+            ax.set_xlabel("Time")
+            ax.set_ylabel("Amp")
+            ax.grid(True, linestyle='--', alpha=0.5)
+            ax.legend(fontsize=8, loc='upper right')
+
+        plt.tight_layout(rect=[0, 0, 1, 0.94])
+        plt.close(fig)
+        return fig

qubitclient/draw/t2fitplyplotter.py

@@ -0,0 +1,111 @@
+# src/draw/t2fitplyplotter.py
+from .plyplotter import QuantumDataPlyPlotter
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import numpy as np
+
+
+class T2FitDataPlyPlotter(QuantumDataPlyPlotter):
+    def __init__(self):
+        super().__init__("t2fit")
+
+    def plot_result_npy(self, **kwargs):
+        result     = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')   # 统一使用 dict_param
+
+        if not result or not dict_param:
+            fig = go.Figure()
+            fig.add_annotation(text="Missing data", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+
+        data = dict_param.item() if isinstance(dict_param, np.ndarray) else dict_param
+        image_dict = data.get("image", {})
+        if not image_dict:
+            fig = go.Figure()
+            fig.add_annotation(text="No image data", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+
+        qubit_names = list(image_dict.keys())
+        n_qubits = len(qubit_names)
+        cols = min(3, n_qubits)
+        rows = (n_qubits + cols - 1) // cols
+
+        fig = make_subplots(
+            rows=rows, cols=cols,
+            subplot_titles=[f"{q}" for q in qubit_names],
+            vertical_spacing=0.09,
+            horizontal_spacing=0.09,
+        )
+
+        params_list   = result.get("params_list", [])
+        r2_list       = result.get("r2_list", [])
+        fit_data_list = result.get("fit_data_list", [])
+
+        data_legend = False
+        fit_legend  = False
+
+        for q_idx, q_name in enumerate(qubit_names):
+            row = q_idx // cols + 1
+            col = q_idx % cols + 1
+
+            item = image_dict[q_name]
+            if not isinstance(item, (list, tuple)) or len(item) < 2:
+                continue
+
+            x_raw = np.asarray(item[0])
+            y_raw = np.asarray(item[1])
+
+            fig.add_trace(go.Scatter(
+                x=x_raw, y=y_raw,
+                mode='markers',
+                marker=dict(color='orange', size=7),
+                name='Data', legendgroup='data',
+                showlegend=not data_legend
+            ), row=row, col=col)
+            if not data_legend:
+                data_legend = True
+
+            if q_idx < len(fit_data_list):
+                y_fit = np.asarray(fit_data_list[q_idx])
+                if len(y_fit) != len(x_raw):
+                    x_fit = np.linspace(x_raw.min(), x_raw.max(), len(y_fit))
+                else:
+                    x_fit = x_raw
+
+                fig.add_trace(go.Scatter(
+                    x=x_fit, y=y_fit,
+                    mode='lines',
+                    line=dict(color='blue', width=2.5),
+                    name='Fit', legendgroup='fit',
+                    showlegend=not fit_legend
+                ), row=row, col=col)
+                if not fit_legend:
+                    fit_legend = True
+
+            if q_idx < len(params_list):
+                A, B, T1, T2, w, phi = params_list[q_idx]
+                r2 = r2_list[q_idx] if q_idx < len(r2_list) else 0.0
+                txt = (f"A={A:.3f}<br>B={B:.3f}<br>T1={T1:.1f}µs<br>"
+                       f"T2={T2:.1f}µs<br>ω={w/1e6:.2f}MHz<br>φ={phi:.3f}<br>R²={r2:.4f}")
+                fig.add_annotation(
+                    x=x_raw[0], y=max(y_raw) * 1.08,
+                    text=txt, showarrow=False,
+                    font=dict(size=9), align="left",
+                    bgcolor="rgba(255,255,255,0.8)", bordercolor="gray",
+                    row=row, col=col
+                )
+
+            if row == rows:
+                fig.update_xaxes(title_text="Time", row=row, col=col)
+            if col == 1:
+                fig.update_yaxes(title_text="Amp", row=row, col=col)
+
+        fig.update_layout(
+            height=440 * rows,
+            width=540 * cols,
+            title_text="T2 Ramsey / Echo Fit",
+            title_x=0.5,
+            legend=dict(font=dict(size=10)),
+            margin=dict(l=60, r=60, t=90, b=60)
+        )
+        return fig

qubitclient/nnscope/nnscope.py

@@ -0,0 +1,51 @@
+# -*- 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 .task import run_task
+import logging
+import numpy as np
+
+
+
+logging.basicConfig(level=logging.INFO)
+
+
+class QubitNNScopeClient(object):
+    def __init__(self, url, api_key):
+        self.url = url
+        self.api_key = api_key
+
+    def request(self, file_list:list[str|dict[str,np.ndarray]|np.ndarray],task_type:str="s21peak",*args,**kwargs):
+        if len(file_list)>0:
+            response = run_task(file_list=file_list,url=self.url,api_key=self.api_key,task_type=task_type,*args,**kwargs)
+        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.json())
+            result = response.json()
+            result = result["result"]
+            return result
+        else:
+            logging.error("Error: %s %s", response.status_code, response.text)
+            return []
+    

qubitclient/nnscope/nnscope_api/curve/curve_type.py

@@ -0,0 +1,15 @@
+# -*- 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/06/06 16:52:53
+########################################################################
+
+
+from enum import Enum
+
+class CurveType(str, Enum):
+    COSINE = "cosin"
+    POLY = "poly"