half-sample 0.1.18__tar.gz

half_sample-0.1.18/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: half_sample
+Version: 0.1.18
+Summary: sample data and analysis
+Home-page: https://github.com/KD-Group/Half.Sample
+Author: kunde
+Author-email: gzkunde@163.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+
+UNKNOWN
+

half_sample-0.1.18/README.md

@@ -0,0 +1,20 @@
+# Half.Sample
+
+[![Build status](https://ci.appveyor.com/api/projects/status/04ox7guybqotu67d?svg=true)](https://ci.appveyor.com/project/Wingsgo/half-sample)
+
+Sample, C++ Program in Half Application with Python Module
+
+## Requirements
+
+Python Requirements:
+
+1. st
+2. typing
+
+Others:
+
+1. C++11 environment
+2. scons
+
+You can also refer to the Travis-CI config file: `.travis.yml`, or Appveyor config file: `appveyor.yml`.
+

half_sample-0.1.18/half_sample.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: half-sample
+Version: 0.1.18
+Summary: sample data and analysis
+Home-page: https://github.com/KD-Group/Half.Sample
+Author: kunde
+Author-email: gzkunde@163.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+
+UNKNOWN
+

half_sample-0.1.18/half_sample.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+setup.py
+cpp_build/sample.exe
+half_sample.egg-info/PKG-INFO
+half_sample.egg-info/SOURCES.txt
+half_sample.egg-info/dependency_links.txt
+half_sample.egg-info/top_level.txt
+sample/__init__.py
+sample/process.py
+sample/result.py
+sample/sample.py

half_sample-0.1.18/half_sample.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

half_sample-0.1.18/half_sample.egg-info/top_level.txt

@@ -0,0 +1 @@
+sample

half_sample-0.1.18/sample/__init__.py

@@ -0,0 +1,3 @@
+from .process import Process
+from .result import Result
+from .sample import Sampler, sampler

half_sample-0.1.18/sample/process.py

@@ -0,0 +1,154 @@
+import time
+import logging
+import sys
+import threading
+import subprocess
+import multiprocessing
+
+
+logger = logging.getLogger('library')
+
+
+def process(target, args=(), finished=None):
+    p = multiprocessing.Process(target=target, args=args)
+    p.start()
+
+    def check_finished():
+        p.join()
+        finished()
+
+    threading.Thread(target=check_finished).start()
+
+
+class Process:
+    def __init__(self, cmd):
+        self.cmd = cmd
+        self.p = None
+        self._max_retries = 1
+        self._start_process()
+
+    def set_max_retry(self, max_retries):
+        self._max_retries = max_retries
+
+    def get_max_retry(self):
+        return self._max_retries
+
+    def _start_process(self):
+        """启动或重启子进程"""
+        if self.p is not None:
+            # 如果旧进程还在运行，先终止它
+            try:
+                if self.p.poll() is None:  # 进程仍在运行
+                    self.p.terminate()
+                    self.p.wait(timeout=3)
+            except Exception as e:
+                logger.warning(f"failed to poll: {e}")
+                try:
+                    self.p.kill()
+                    self.p.wait()
+                except Exception as e:
+                    logger.warning(f"failed to kill: {e}")
+                    pass
+        # 启动新进程
+        self.p = subprocess.Popen(self.cmd,
+                                  shell=False,
+                                  creationflags=0x00000008 if sys.platform == "win32" else 0,
+                                  stdin=subprocess.PIPE,
+                                  stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+
+    def _is_process_alive(self):
+        """检查进程是否存活"""
+        if self.p is None:
+            return False
+        return self.p.poll() is None
+
+    def _ensure_process_alive(self):
+        """确保进程存活，如果崩溃则重启"""
+        if not self._is_process_alive():
+            logger.warning(f"subprocess [{self.cmd}] crash, restarting...")
+            self._start_process()
+            logger.warning(f"subprocess [{self.cmd}] restart completed")
+
+    def write_line(self, line: str):
+        """写入一行数据，自动处理进程重启"""
+        for attempt in range(self._max_retries):
+            try:
+                self._ensure_process_alive()
+                self.p.stdin.write(line.encode())
+                self.p.stdin.write('\n'.encode())
+                self.p.stdin.flush()
+                return  # 成功写入，退出重试循环
+            except (BrokenPipeError, OSError) as e:
+                if attempt < self._max_retries - 1:
+                    logger.warning(f"write line failed (attempted {attempt + 1}/{self._max_retries}): {e}")
+                    self._start_process()  # 重启进程
+                    time.sleep(0.1)  # 短暂等待新进程启动
+                else:
+                    raise RuntimeError(f"无法向子进程写入数据，已重试{self._max_retries}次: {e}")
+
+    def read_line(self) -> str:
+        """读取一行数据，自动处理进程重启"""
+        for attempt in range(self._max_retries):
+            try:
+                self._ensure_process_alive()
+                line = self.p.stdout.readline()
+                if not line:  # EOF，进程可能已终止
+                    if not self._is_process_alive():
+                        raise RuntimeError("子进程已终止")
+                    return ""
+                return line.decode().replace('\r\n', '').replace('\n', '')
+            except (OSError, RuntimeError) as e:
+                if attempt < self._max_retries - 1:
+                    logger.warning(f"read line failed (attempted {attempt + 1}/{self._max_retries}): {e}")
+                    self._start_process()  # 重启进程
+                    time.sleep(0.1)  # 短暂等待新进程启动
+                else:
+                    raise RuntimeError(f"无法从子进程读取数据，已重试{self._max_retries}次: {e}")
+
+    def read_until(self, until):
+        """读取直到指定字符串，自动处理进程重启"""
+        lines = []
+
+        for attempt in range(self._max_retries):
+            try:
+                while True:
+                    line = self.read_line()
+                    if line == until:
+                        return '\n'.join(lines)
+                    elif not line:
+                        break
+                    else:
+                        lines.append(line)
+            except (RuntimeError, OSError) as e:
+                if attempt < self._max_retries - 1:
+                    logger.warning(f"read_until failed (attempted {attempt + 1}/{self._max_retries}): {e}")
+                    self._start_process()  # 重启进程
+                    lines = []  # 清空已读取的行
+                    time.sleep(0.1)
+                else:
+                    raise RuntimeError(f"read_until 失败，已重试{self._max_retries}次: {e}")
+
+        return '\n'.join(lines)
+
+    def terminate(self):
+        """终止子进程"""
+        if self.p is not None and self.p.poll() is None:
+            try:
+                self.p.terminate()
+                self.p.wait(timeout=3)
+            except subprocess.TimeoutExpired as e:
+                logger.warning(f"Timeout expired while trying to terminate [{self.cmd}]: {e}")
+                try:
+                    self.p.kill()
+                    self.p.wait()
+                except Exception as e:
+                    logger.warning(f"Failed to kill [{self.cmd}]: {e}")
+            except Exception as e:
+                logger.warning(f"Failed to terminate [{self.cmd}]: {e}")
+
+    def get_return_code(self):
+        """获取进程返回码"""
+        if self.p is not None:
+            return self.p.poll()
+        return None

half_sample-0.1.18/sample/result.py

@@ -0,0 +1,120 @@
+import math
+
+
+class Result:
+    ErrorMessageMapper = {
+        # 基础状态
+        "success": "成功",
+
+        # 用户操作错误
+        "command_not_found": "命令不存在",
+        "sampler_not_found": "采样器不存在",
+        "now_in_measuring": "正在测量中",
+        "file_not_found": "文件未找到",
+
+        # 采样错误
+        "voltage_not_enough": "电压不足",
+        "wave_not_found": "未找到波形",
+        "appropriate_wave_not_found": "未找到合适波形",
+
+        # 警告类错误
+        "warning_intr_not_available": "中断资源不可用",
+        "warning_param_out_of_range": "参数超出范围",
+        "warning_prop_value_out_of_range": "属性值超出范围",
+        "warning_prop_value_not_spted": "属性值不支持",
+        "warning_prop_value_conflict": "属性值状态冲突",
+        "warning_vrg_of_group_not_same": "通道组量程不一致",
+
+        # 系统级错误
+        "error_handle_not_valid": "句柄无效",
+        "error_param_out_of_range": "参数超出范围",
+        "error_param_not_spted": "参数不支持",
+        "error_param_fmt_unexpted": "参数格式异常",
+        "error_memory_not_enough": "内存不足",
+        "error_buffer_is_null": "缓冲区为空",
+        "error_buffer_too_small": "缓冲区过小",
+        "error_data_len_exceed_limit": "数据长度超限",
+        "error_func_not_spted": "功能不支持",
+        "error_event_not_spted": "事件不支持",
+        "error_prop_not_spted": "属性不支持",
+        "error_prop_read_only": "属性只读",
+        "error_prop_value_conflict": "属性值冲突",
+        "error_prop_value_out_of_range": "属性值超限",
+        "error_prop_value_not_spted": "属性值不支持",
+        "error_privilege_not_held": "权限未持有",
+        "error_privilege_not_available": "权限不可用",
+        "error_driver_not_found": "驱动未找到",
+        "error_driver_ver_mismatch": "驱动版本不匹配",
+        "error_driver_count_exceed_limit": "驱动数量超限",
+        "error_device_not_opened": "设备未打开",
+        "error_device_not_exist": "设备不存在",
+        "error_device_unrecognized": "设备未识别",
+        "error_config_data_lost": "配置数据丢失",
+        "error_func_not_inited": "功能未初始化",
+        "error_func_busy": "功能忙",
+        "error_intr_not_available": "中断不可用",
+        "error_dma_not_available": "DMA通道不可用",
+        "error_device_io_time_out": "设备IO超时",
+        "error_signature_not_match": "签名不匹配",
+        "error_func_conflict_with_bfd_ai": "功能与缓冲AI冲突",
+        "error_vrg_not_available_in_se_mode": "单端模式量程不可用",
+        "error_undefined": "未定义错误"
+    }
+
+    def __init__(self):
+        self.error = False
+        self.message = ''
+
+        self.sampler_name = ''
+        self.measuring = False
+        self.success = False
+        self.with_magnetic = False
+
+        self.sampling_interval = 0.0  # us
+        self.wave_interval = 0.0  # us
+        self.waveforms_per_sample = 0.0  # 采集卡每次采样时能得到的最大波形数量，可能采集到部分波形，因此为double类型，例如0.5
+        self.sampling_time = 1  # 采样次数,当要求的波形数量大于采集卡单次最大采样点数的时，进行多次采样直到能采集到要求的波形
+        self.sampling_length_per_sample = 0  # 采集卡单次采样点数
+        self.waveform_length = 0  # 一个完整波形的点数(包括上升沿和下降沿)
+        self.valid_length = 0  # 有效的波形点数(仅包含上升沿部分)
+        self.number_of_waveforms = 0  # 波形平均次数
+        self.wave = []
+        self.time_line = []
+        self.estimate = []
+
+        self.tau = 0.0
+        self.tau_b = 0.0
+        self.w = 0.0
+        self.b = 0.0
+        self.loss = 0.0
+
+        self.v0 = 0.0
+        self.v_inf = 0.0
+
+        self.mock_tau = 0.0
+        self.mock_v0 = 0.0
+        self.mock_v_inf = 0.0
+        self.mock_noise = 0.0
+
+        self.rho = 0.0
+        self.miu = 0.0
+        self.carrier = 0.0
+        self.corrected_rho = 0.0
+        self.corrected_miu = 0.0
+        self.corrected_carrier = 0.0
+
+    def process(self):
+        self.time_line = [self.wave_interval * i for i in range(len(self.wave))]
+
+        if self.success:
+            tau, w, b = self.tau, self.w, self.b
+            self.estimate = [w * math.exp(t / -tau) + b for t in self.time_line]
+
+            self.v0, self.v_inf = b + w, b
+
+    @property
+    def chinese_message(self) -> str:
+        try:
+            return self.ErrorMessageMapper[self.message]
+        except Exception as e:
+            return self.message

half_sample-0.1.18/sample/sample.py

@@ -0,0 +1,97 @@
+import os
+import shutil
+
+from . import Process
+from . import Result
+
+
+class Sampler:
+    @property
+    def execution_path(self) -> str:
+        main_path = os.path.join(os.path.dirname(__file__), '..')
+
+        # build if SConstruct file exists
+        if os.path.exists(os.path.join(main_path, 'SConstruct')):
+            if os.system('cd {} && scons'.format(main_path)) != 0:
+                raise self.Error("Compile C++ Driver Error")
+
+        # try to use cpp_build/sample.exe when developing
+        execution_name = 'sample.exe'
+        if not os.path.exists(execution_name):
+            execution_name = os.path.join(main_path, 'cpp_build', execution_name)
+        if os.path.exists(execution_name):
+            return os.path.abspath(execution_name)
+
+        # try to find sample.exe in system path when release
+        if shutil.which("sample.exe"):
+            return shutil.which("sample.exe")
+
+        raise self.Error('Sample Driver Not Found')
+
+    @property
+    def p(self) -> Process:
+        p = getattr(self, 'p_', None)
+        if p is not None:
+            return p
+
+        p = Process(self.execution_path)
+        setattr(self, 'p_', p)
+        return p
+
+    def communicate(self, command: str, executor: Process = None) -> Result:
+        result = Result()
+        try:
+            executor = executor or self.p
+            executor.write_line(command)
+            lines = executor.read_until('EOF')
+            if lines:
+                exec(lines, result.__dict__)
+        except Exception as e:
+            result.error = True
+            result.message = str(e)
+            raise self.Error("{}: {}".format(result.message, result.chinese_message))
+
+        if result.error:
+            raise self.Error("{}: {}".format(result.message, result.chinese_message))
+
+        return result
+
+    @property
+    def is_measuring(self) -> bool:
+        return self.communicate('is_measuring').measuring
+
+    def measure(self, number_of_waveforms: int, emitting_frequency: float, auto_mode: bool = False) -> Result:
+        return self.communicate("to_measure {} {:.2f} {}".format(number_of_waveforms, emitting_frequency, auto_mode))
+
+    def dump(self, filename: str, number_of_waveforms: int, emitting_frequency: float,
+             auto_mode: bool = False) -> Result:
+        return self.communicate(
+            "to_dump {} {} {:.2f} {}".format(filename, number_of_waveforms, emitting_frequency, auto_mode))
+
+    def process(self, filename: str) -> Result:
+        return self.communicate("to_process {}".format(filename))
+
+    def set_sampler(self, sampler_name: str) -> Result:
+        return self.communicate("set_sampler {}".format(sampler_name))
+
+    def get_sampler(self) -> Result:
+        return self.communicate("get_sampler")
+
+    def set_sampler_value(self, key: str, value: float) -> Result:
+        return self.communicate("set_sampler_value {} {}".format(key, value))
+
+    def get_sampler_value(self, key: str) -> Result:
+        return self.communicate("get_sampler_value {}".format(key))
+
+    def query(self) -> Result:
+        result = self.communicate("to_query")
+        result.process()
+        if not result.success and result.message == "success":
+            result.message = "error_undefined"
+        return result
+
+    class Error(RuntimeError):
+        pass
+
+
+sampler = Sampler()

half_sample-0.1.18/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

half_sample-0.1.18/setup.py

@@ -0,0 +1,18 @@
+import setuptools
+
+setuptools.setup(
+    name="half_sample",
+    version="0.1.18",
+    author="kunde",
+    author_email="gzkunde@163.com",
+    description="sample data and analysis",
+    long_description="",
+    url="https://github.com/KD-Group/Half.Sample",
+    packages=["sample"],
+    classifiers=(
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ),
+    data_files=[('cpp_build/sample.exe')]
+)