datacom-device-api 0.1.5__py3-none-any.whl

datacom_device_api/data/table.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVarTuple, Unpack
+
+Ts = TypeVarTuple('Ts')
+
+@dataclass
+class Table(Generic[Unpack[Ts]]):
+    table_name: str
+    headers: list[str]
+    fragment_refrence_size: int
+    total_fragment: int
+    total_row: int
+    fragments: list[TableFragment[Unpack[Ts]]]
+    def __post_init__(self):
+        for fragment in self.fragments:
+            if fragment.fragment_offset < 0 or fragment.fragment_size <= 0:
+                raise ValueError('Invalid fragment offset or size')
+            if len(fragment.rows) > fragment.fragment_size:
+                raise ValueError('Invalid fragment size or row count')
+
+@dataclass
+class TableFragment(Generic[Unpack[Ts]]):
+    fragment_offset: int
+    fragment_size: int
+    rows: list[tuple[Unpack[Ts]]]

datacom_device_api/operation/table_operation.py

@@ -0,0 +1,89 @@
+
+from typing import Any, Callable, Generic, Optional, TypeVar, TypeVarTuple, Union, Unpack, overload
+
+from datacom_device_api.data.table import Table, TableFragment
+
+Ts = TypeVarTuple('Ts')
+
+class TableOperation(Generic[Unpack[Ts]]):
+    def __init__(
+            self, 
+            table_name: str, 
+            headers: list[str], 
+            fragment_refrence_size: int = 1000
+        ) -> None:
+        self.__table = Table[Unpack[Ts]](
+            table_name=table_name,
+            headers=headers,
+            fragment_refrence_size=fragment_refrence_size,
+            total_fragment=0,
+            total_row=0,
+            fragments=[],
+        )
+    
+    def add_fragment(self, fragment: TableFragment[Unpack[Ts]]) -> None:
+        if fragment.fragment_size > self.__table.fragment_refrence_size:
+            raise ValueError('fragment size is too large')
+        
+        self.__table.fragments.append(fragment)
+        self.__table.total_fragment += 1
+        self.__table.total_row += len(fragment.rows)
+        
+    @property
+    def fragment_refrence_size(self) -> int:
+        return self.__table.fragment_refrence_size
+    
+    def get_row_by_row_index(self, row_index: int) -> Optional[tuple[Unpack[Ts]]]:
+        if row_index >= self.__table.total_row:
+            raise ValueError('row index is out of range')
+        
+        self.__table.fragments.sort(key=lambda fragment: fragment.fragment_offset)
+        
+        fragment_index = row_index // self.__table.fragment_refrence_size
+        fragment = self.__table.fragments[fragment_index]
+        
+        return fragment.rows[row_index % fragment.fragment_size]
+    
+    @overload
+    def get_row_by_header(self, header: str, value: Any) -> list[tuple[*Ts]]: ...
+    @overload
+    def get_row_by_header(self, header: int, value: Any) -> list[tuple[*Ts]]: ...
+    
+    def get_row_by_header(self, header: Any, value: Any) -> list[tuple[*Ts]]:
+        if isinstance(header, int): 
+            header_index = header
+        elif isinstance(header, str):
+            if header not in self.__table.headers:
+                raise ValueError('header name not found')
+            header_index = self.__table.headers.index(header)
+        else:
+            raise ValueError('header must be int or str')
+        
+        if type(value) not in [*Ts]:
+            raise ValueError('value type of value')
+        
+        result = []        
+        for fragment in self.__table.fragments:
+            for row in fragment.rows:
+                if row[header_index] == value:
+                    result.append(row)
+        
+        return result
+    
+    @property
+    def table(self) -> Table[Unpack[Ts]]:
+        return self.__table
+
+    @property
+    def headers(self) -> list[str]:
+        return self.__table.headers
+    
+    def for_each_row_by_fragment_index(self, fragment_index: int, callback: Callable[[tuple[*Ts]], None]):
+        fragment = self.__table.fragments[fragment_index]
+        for row in fragment.rows:
+            callback(row)
+            
+    def for_each_all(self, callback: Callable[[tuple[*Ts]], None]):
+        for frament in self.__table.fragments:
+            for row in frament.rows:
+                callback(row)

datacom_device_api/operation/table_read_from_xlsx.py

@@ -0,0 +1,103 @@
+from typing import Any, Callable, Generic, TypeVarTuple
+
+from openpyxl import Workbook, load_workbook
+
+from datacom_device_api.data.table import Table, TableFragment
+from datacom_device_api.operation.table_operation import TableOperation
+
+
+Ts = TypeVarTuple('Ts')
+
+class TableReadFromXlsx(Generic[*Ts]):
+    def __init__(self, xlsx_file_path: str) -> None:
+        try:
+            self.__workbook = load_workbook(xlsx_file_path, read_only=True)
+        except FileNotFoundError:
+            raise FileNotFoundError(f"{xlsx_file_path} is not found.")
+        except Exception as e:
+            raise e
+    
+    @property
+    def get_sheet_names(self) -> list[str]:
+        return self.__workbook.sheetnames
+        
+    
+    def _generate_table_fragment(self, worksheet, min_row: int, max_row: int, convert_func: Callable[[str, Any], Any], headers: list[str]) -> TableFragment[*Ts]:
+        if not hasattr(worksheet, 'iter_rows'):
+            raise AttributeError("worksheet does not have iter_rows method.")
+        
+        row_datas: list[tuple] = []
+        for row_data in worksheet.iter_rows(min_row=min_row, max_row=max_row):
+            tmp = tuple(convert_func(headers[i], row_data[i].value ) for i in range(len(headers)))
+            print(tmp)
+            row_datas.append(tmp)
+        
+        if min_row == 1 or min_row == 2:
+            fragment_offset = 0
+        else:
+            fragment_offset = min_row - 1
+        
+        return TableFragment[*Ts](
+            rows=row_datas,
+            fragment_offset=fragment_offset,
+            fragment_size=len(row_datas),
+        )
+        
+    def generate_table_data(self, sheet_name: str, convert_func: Callable[[str, Any], Any]) -> Table[*Ts]:
+        if sheet_name not in self.__workbook.sheetnames:
+            raise ValueError(f"{sheet_name} is not found.")
+        
+        worksheet = self.__workbook[sheet_name]
+        total_rows = worksheet.max_row - 1
+        
+        headers = []
+        for row_data in worksheet.iter_rows(min_row=1, max_row=1): 
+            headers.extend([item.value for item in row_data])
+
+        table = TableOperation[*Ts](
+            table_name=sheet_name,
+            headers=headers,
+        )
+    
+        fragments_count = -(-total_rows // table.fragment_refrence_size)
+        fragments_size = []
+        
+        remaining_count = total_rows
+        for _ in range(fragments_count):
+            remaining_count -= (table.fragment_refrence_size)
+            if remaining_count < 0:
+                fragments_size.append(remaining_count + table.fragment_refrence_size)
+            else:
+                fragments_size.append(table.fragment_refrence_size)
+        
+        offset = 2
+        for size in fragments_size:
+            fragment = self._generate_table_fragment(
+                worksheet=worksheet,
+                min_row=offset,
+                max_row=offset + size - 1,
+                convert_func=convert_func,
+                headers=headers,
+            )
+            
+            table.add_fragment(fragment)
+            offset += size
+        
+        return table.table
+
+def _convert_func(header: str, value: Any) -> Any:
+    if header == 'USER_NAME':
+        return str(value)
+    return value
+
+if __name__ == "__main__":
+    xlsx_file = "C:\\Users\\24168\\Projects\\Datacom_tools\\tables\\test.xlsx"
+    sheet_name = "Sheet1"
+    xlsx = TableReadFromXlsx(xlsx_file)
+    xlsx.generate_table_data(sheet_name, _convert_func)
+
+    # workbook = load_workbook(xlsx_file, read_only=True)
+    # sheet = workbook[sheet_name]
+    
+    # for row_data in sheet.iter_rows(min_row=1, max_row=10): 
+    #     print(row_data)

datacom_device_api/operation/table_save_to_db.py

@@ -0,0 +1,20 @@
+from typing import Generic, TypeVarTuple, Unpack
+from pymysql.cursors import Cursor
+from pymysql.connections import Connection
+from datacom_device_api.data.table import Table
+
+Ts = TypeVarTuple('Ts')
+
+class TableSaveToDB(Generic[Unpack[Ts]]):
+    def __init__(self, connect: Connection) -> None:
+        self.__cursor = connect.cursor()
+        self.__conn = connect
+    def save_to_db(self, db_table_name: str, table: Table[Unpack[Ts]]) -> None:
+        sql = f'INSERT INTO {db_table_name} VALUES ({",".join(["%s"] * len(table.headers))})'
+        
+        for fragment in table.fragments:
+            values_list = fragment.rows
+            self.__cursor.executemany(sql, values_list)
+            self.__conn.commit()
+        print(table)
+        

datacom_device_api/process/terminal_process.py

@@ -0,0 +1,244 @@
+"""多进程任务执行与进度展示封装。
+
+提供 TerminalProcess 类，封装 ProcessPoolExecutor 和 Rich Progress，
+支持任务提交、进度监听、异常处理、上下文管理器等能力。
+"""
+
+from concurrent.futures import Future, ProcessPoolExecutor
+from dataclasses import dataclass
+from functools import partial
+from multiprocessing import Manager
+import os
+import queue
+import threading
+from typing import Any, Callable, Optional
+from uuid import UUID
+import uuid
+
+from rich.progress import Progress, TaskID
+
+REPORT_FUNC_TYPE = Callable[[float, float, str], None]
+EXECUTE_FUNC_TYPE = Callable[[REPORT_FUNC_TYPE], Any]
+
+
+@dataclass
+class ProgressMessage:
+    """进程间传递的进度消息。
+
+    Attributes:
+        type: 消息类型，取值为 'progress' / 'done' / 'error'
+        task_id: 任务唯一标识
+        message: 进度描述文本
+        progress: 当前进度值
+        total: 总进度值
+    """
+
+    type: str
+    task_id: UUID
+    message: str
+    progress: float
+    total: float
+
+
+__PROGRESS_UPDATE_FN_TYPE = Callable[[ProgressMessage], None]
+
+
+class TerminalProcess:
+    """多进程任务执行器，支持进度展示与监听器机制。
+
+    每个实例拥有独立的进程池、进度队列和进度条，
+    多实例之间状态互不干扰。
+
+    用法:
+        with TerminalProcess() as process:
+            process.submit(task1)
+            process.submit(task2)
+    """
+
+    def __init__(self, max_workers: Optional[int] = None):
+        """初始化终端进程执行器。
+
+        Args:
+            max_workers: 进程池最大并发数，默认为 CPU 核心数
+        """
+        self.__pool = ProcessPoolExecutor(max_workers=max_workers or os.cpu_count())
+        self.__manager = Manager()
+        self.__progress_queue: queue.Queue[ProgressMessage] = self.__manager.Queue()
+
+        self.__task_future_count = 0
+        self.__tasks: dict[UUID, Future[Any]] = {}
+        self.__task_update_lisening_fn_dict: dict[UUID, list[__PROGRESS_UPDATE_FN_TYPE]] = {}
+
+        self.__progress_thread_stop_event = threading.Event()
+        self.__progress_tasks: dict[UUID, TaskID] = {}
+        self.__progress = Progress()
+        self.__progress_thread: Optional[threading.Thread] = None
+        self.__progress_main_task: TaskID = self.__progress.add_task(
+            'main', total=self.__task_future_count
+        )
+
+    def trigger_progress(self, task_id: UUID, message: ProgressMessage) -> None:
+        """触发指定任务的所有进度监听器。
+
+        若 task_id 未注册监听器则静默跳过。
+        """
+        listening_fns = self.__task_update_lisening_fn_dict.get(task_id, [])
+        for fn in listening_fns:
+            fn(message)
+
+    def listen_progress(self, task_id: UUID, fn: __PROGRESS_UPDATE_FN_TYPE) -> None:
+        """为指定任务注册一个进度监听器。
+
+        同一任务可注册多个监听器，按注册顺序依次调用。
+        """
+        self.__task_update_lisening_fn_dict.setdefault(task_id, []).append(fn)
+
+    def update_progress(self, message: ProgressMessage) -> None:
+        """更新内置进度条的显示。
+
+        任务完成时自动推进主进度条计数。
+        若消息对应的任务不存在则静默跳过。
+        """
+        task_id = self.__progress_tasks.get(message.task_id)
+        if task_id is None:
+            return
+        self.__progress.update(task_id, completed=message.progress, total=message.total)
+        self.__progress.refresh()
+
+        if message.type == 'done':
+            self.__progress.update(self.__progress_main_task, advance=1)
+
+    @staticmethod
+    def _warrper_fn(
+        fn: EXECUTE_FUNC_TYPE,
+        progress_queue: queue.Queue[ProgressMessage],
+        task_id: UUID,
+        *args,
+        **kwargs,
+    ) -> Any:
+        """任务包装函数，在子进程中执行。
+
+        封装进度上报、完成标记和异常处理，通过队列将进度消息
+        发送回主进程。任务正常结束或异常均会发送对应类型的消息。
+        """
+        done_send = False
+
+        def report(progress: float, total: float, message: str, msg_type: str = 'progress'):
+            nonlocal done_send
+
+            if done_send:
+                return
+
+            current_type = msg_type
+            if progress >= total:
+                current_type = 'done'
+                done_send = True
+
+            progress_queue.put(ProgressMessage(
+                type=current_type,
+                task_id=task_id,
+                message=message,
+                progress=progress,
+                total=total,
+            ))
+
+        try:
+            result = fn(report, *args, **kwargs)
+            if not done_send:
+                report(100, 100, 'done', msg_type='done')
+            return result
+        except Exception as e:
+            progress_queue.put(ProgressMessage(
+                type='error',
+                task_id=task_id,
+                message=str(e),
+                progress=0,
+                total=0,
+            ))
+            raise
+
+    def run_display_progress(self) -> None:
+        """进度消费线程主循环。
+
+        持续从队列中取出进度消息，依次更新内置进度条并触发监听器。
+        使用带超时的轮询避免阻塞，确保停止事件触发后能及时退出。
+        """
+        while not self.__progress_thread_stop_event.is_set() or not self.__progress_queue.empty():
+            try:
+                message = self.__progress_queue.get(timeout=0.1)
+                self.update_progress(message)
+                self.trigger_progress(message.task_id, message)
+            except queue.Empty:
+                if (
+                    self.__progress_thread_stop_event.is_set()
+                    and all(futrue.done() for futrue in self.__tasks.values())
+                ):
+                    break
+
+    def submit(
+        self,
+        fn: EXECUTE_FUNC_TYPE,
+        task_name: Optional[str] = None,
+        *args,
+        **kwargs,
+    ) -> Optional[Future[Any]]:
+        """提交一个任务到进程池执行。
+
+        Args:
+            fn: 任务函数，第一个参数为 report 回调，签名为 (progress, total, message)
+            task_name: 进度条显示的任务名，默认为 task_{uuid}
+            *args: 传递给任务函数的位置参数
+            **kwargs: 传递给任务函数的关键字参数
+
+        Returns:
+            任务的 Future 对象，可用于获取结果或异常
+        """
+        task_id = uuid.uuid4()
+        task_fn = partial(TerminalProcess._warrper_fn, fn, self.__progress_queue, task_id)
+        future = self.__pool.submit(task_fn, *args, **kwargs)
+        self.__tasks[task_id] = future
+        self.__task_update_lisening_fn_dict[task_id] = []
+
+        self.__task_future_count += 1
+        progress_task = self.__progress.add_task(task_name or f'task_{task_id}', total=1)
+        self.__progress_tasks[task_id] = progress_task
+        self.__progress.refresh()
+
+        self.__progress.update(self.__progress_main_task, total=self.__task_future_count)
+        return future
+
+    def start(self) -> None:
+        """启动进度条显示与消息消费线程。"""
+        self.__progress.start()
+        self.__progress_thread_stop_event.clear()
+        self.__progress_thread = threading.Thread(target=self.run_display_progress)
+        self.__progress_thread.start()
+
+    def shutdown(self) -> None:
+        """停止任务执行并释放资源。
+
+        按顺序执行：等待所有任务完成 → 消费完剩余进度消息 →
+        关闭进程池 → 停止进度条。确保不会因消息未消费完而丢失进度。
+        """
+        for future in self.__tasks.values():
+            try:
+                future.result()
+            except Exception:
+                pass
+
+        self.__progress_thread_stop_event.set()
+        if self.__progress_thread is not None:
+            self.__progress_thread.join()
+            self.__progress_thread = None
+
+        self.__pool.shutdown(wait=True)
+        self.__progress.stop()
+
+    def __enter__(self) -> 'TerminalProcess':
+        """进入上下文管理器时自动启动。"""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """退出上下文管理器时自动释放资源。"""
+        self.shutdown()

datacom_device_api/utils/directory_util.py

@@ -0,0 +1,13 @@
+import os
+
+def get_project_root_dir() -> str:
+    return os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+def get_work_dir() -> str:
+    return os.getcwd()
+
+def test():
+    print(get_project_root_dir())
+    print(get_work_dir())
+
+if __name__ == '__main__':
+    test()

datacom_device_api/utils/logger.py

@@ -0,0 +1,14 @@
+import logging
+class Logger(object):
+    def __init__(self, name: str) -> None:
+        self.__logger = logging.getLogger(name)
+        self.__logger.setLevel(logging.INFO)
+        formatter = logging.Formatter('[%(asctime)s-%(levelname)s](%(name)s): %(message)s')
+
+        consolo_handler = logging.StreamHandler()
+        consolo_handler.setLevel(logging.INFO)
+        consolo_handler.setFormatter(formatter)
+        self.__logger.addHandler(consolo_handler)
+        
+    def __getattr__(self, name):
+        return getattr(self.__logger, name)

datacom_device_api-0.1.5.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: datacom-device-api
+Version: 0.1.5
+Summary: Add your description here
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: dataclasses>=0.8
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: ops>=3.8.0
+Requires-Dist: pymysql>=1.2.0
+Requires-Dist: rich>=15.0.0

datacom_device_api-0.1.5.dist-info/RECORD

@@ -0,0 +1,16 @@
+datacom_device_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datacom_device_api/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datacom_device_api/data/table.py,sha256=tl77fUGrP6sRlSZGA4M9fB98O1Ld2udPQqMM8slHCqg,827
+datacom_device_api/operation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datacom_device_api/operation/table_operation.py,sha256=8G9BBytGA6lv4sfBzykuJtIhp9Ejl4I6RXaJVfUyVc0,3295
+datacom_device_api/operation/table_read_from_xlsx.py,sha256=6x7lihDIEfTzbhQaEZ0qbY7IVOPgfd4dSPPTXeWwsz8,3746
+datacom_device_api/operation/table_save_to_db.py,sha256=PkPWnLfyJRfctEbYIQHAVSo4DSbcS6B4jf0IH9VuuHo,768
+datacom_device_api/process/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datacom_device_api/process/terminal_process.py,sha256=ODqi-4W-NLjvHxGyCv_-VceJ9t0QnMBgLlJKEtPDv9Y,8407
+datacom_device_api/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datacom_device_api/utils/directory_util.py,sha256=HCzG73yBoeLDv5dXfKBI6T-TeWH6fjLLSf0SWNfOqJg,307
+datacom_device_api/utils/logger.py,sha256=iyQQTHyhbf_uuNJw95FWD8hy_vVqbzeeNEpZskh1fpI,559
+datacom_device_api-0.1.5.dist-info/METADATA,sha256=jCt2F06zteypOYMCQkAmKRW440H0h70OyOy_UIzjFoU,319
+datacom_device_api-0.1.5.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+datacom_device_api-0.1.5.dist-info/top_level.txt,sha256=KeCYNpjqBXcR2uDjjoZc4uFUuswkUoxnfn-UTGPSfmI,19
+datacom_device_api-0.1.5.dist-info/RECORD,,

datacom_device_api-0.1.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

datacom_device_api-0.1.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+datacom_device_api