dimine-python-sdk 0.1.8__py3-none-any.whl

dimine_python_sdk/lib/types/entity.py

@@ -0,0 +1,957 @@
+import DmPyBindInterface as Dm
+from dimine_python_sdk.lib.types.line import DmDbPolyline, DmDbLine
+from dimine_python_sdk.lib.types.point import DmDPoint, DmPoints, DmDbPoint
+from enum import IntEnum
+from typing import Optional, List, Union
+
+
+class EntityType(IntEnum):
+    ETT_NUKNOWN = -1
+    ETT_POINT = 0
+    ETT_LINE = 1
+    ETT_POLYLINE = 2
+    ETT_SHELL = 3
+    ETT_TEXT = 4
+    ETT_ARC = 5
+    ETT_CIRCLE = 6
+    ETT_ELLIPSE = 7
+    ETT_SPLINE = 8
+    ETT_POLYGON = 9
+    ETT_ANNOTATION = 10
+    ETT_SPHERE = 11
+    ETT_UGRID = 12
+    ETT_WORKPLANE = 13
+    ETT_NET_NODE = 15
+    ETT_NET_EDGE = 16
+    ETT_MODEL = 17
+    ETT_COMPLEX = 18
+    ETT_2DPOLYLINE = 19
+    ETT_LWPOLYLINE = 20
+    ETT_BLOCK = 21
+    ETT_MBLOCK = 22
+    ETT_HATCH = 23
+    ETT_Ordinate_Dim = 24
+    ETT_Aligned_Dim = 25
+    ETT_Rotated_Dim = 26
+    ETT_3PointAngular_Dim = 27
+    ETT_2LineAngular_Dim = 28
+    ETT_Radial_Dim = 29
+    ETT_Diametric_Dim = 30
+    ETT_Arc_Dim = 31
+    ETT_Radial_Large_Dim = 32
+    ETT_MTEXT = 33
+    ETT_MESH = 34
+    ETT_IMAGE = 35
+    ETT_XLINE = 36
+    ETT_RAY = 37
+    ETT_LEADER = 38
+    ETT_MLINE = 39
+    ETT_TABLE = 40
+    ETT_ATT_DEF = 41
+    ETT_ATT = 42
+    ETT_POINT_SET = 43
+    ETT_TEXT_SET = 44
+    ETT_POLYHEDRALSURFACETYPE = 45
+    ETT_CUSTOM_START = 100
+
+
+#三维实体
+class DmDbShell:
+    """shell类"""
+    def __init__(self):
+        """构造函数，初始化Shell对象"""
+        self._obj = Dm.dmDbShell()
+
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        原生对象创建封装实例
+        :param obj: 原生dmDbShell对象
+        :return: DmDbShell实例
+        """
+        instance = cls.__new__(cls)
+        instance._obj = obj
+        return instance
+
+#几何数据
+class DmPolyData:
+    """多边形数据类"""
+
+    def __init__(self):
+        """
+        构造函数：初始化多边形数据对象
+        :return: None
+        """
+        self._obj = Dm.dmPolyData()
+
+    # ---------------------- 基础属性获取 ----------------------
+    def get_data_type(self) -> int:
+        """
+        获取多边形数据类型
+        :return: 数据类型编码（整数）
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        data_type = poly_data.get_data_type()
+        ```
+        """
+        return self._obj.GetDataType()
+
+    def get_number_of_cells(self) -> int:
+        """
+        获取单元格数量
+        :return: 单元格数量（整数）
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        num_cells = poly_data.get_number_of_cells()
+        ```
+        """
+        return self._obj.GetNumberOfCells()
+
+    def get_number_of_verts(self) -> int:
+        """
+        获取顶点数量
+        :return: 顶点数量（整数）
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        num_verts = poly_data.get_number_of_verts()
+        ```
+        """
+        return self._obj.GetNumberOfVerts()
+
+    def get_number_of_lines(self) -> int:
+        """
+        获取线段数量
+        :return: 线段数量（整数）
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        num_lines = poly_data.get_number_of_lines()
+        ```
+        """
+        return self._obj.GetNumberOfLines()
+
+    def get_number_of_polys(self) -> int:
+        """
+        获取多边形数量
+        :return: 多边形数量（整数）
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        num_polys = poly_data.get_number_of_polys()
+        ```
+        """
+        return self._obj.GetNumberOfPolys()
+
+    def get_number_of_points(self) -> int:
+        """
+        获取点的总数量
+        :return: 点数量（整数）
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        num_points = poly_data.get_number_of_points()
+        ```
+        """
+        return self._obj.GetNumberOfPoints()
+
+    def get_bounds(self) -> list[float]:
+        """
+        获取数据的包围盒
+        :return: 包围盒坐标列表 [min_x, max_x, min_y, max_y, min_z, max_z]
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        bounds = poly_data.get_bounds()
+        ```
+        """
+        return self._obj.GetBounds()
+
+    # ---------------------- 单元格插入 ----------------------
+    def insert_next_vert_cell(self, point_indexes: list[int]) -> None:
+        """
+        插入顶点单元格
+        :param point_indexes: 点索引列表（整数列表）
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        poly_data.insert_next_vert_cell([0, 1, 2])
+        ```
+        """
+        self._obj.InsertNextVertCell(point_indexes)
+
+    def insert_next_line_cell(self, point_indexes: list[int]) -> None:
+        """
+        插入线段单元格
+        :param point_indexes: 点索引列表（整数列表）
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        poly_data.insert_next_line_cell([0, 1, 2])
+        ```
+        """
+        self._obj.InsertNextLineCell(point_indexes)
+
+    def insert_next_poly_cell(self, point_indexes: list[int]) -> None:
+        """
+        插入多边形单元格
+        :param point_indexes: 点索引列表（整数列表）
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        poly_data.insert_next_poly_cell([0, 1, 2])
+        ```
+        """
+        self._obj.InsertNextPolyCell(point_indexes)
+
+    # ---------------------- 点操作 ----------------------
+    def insert_unique_point(self, point: DmDPoint) -> int:
+        """
+        插入唯一的点（自动去重）
+        :param point: 待插入的点（DmDPoint实例）
+        :return: 点的唯一ID（整数）
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        point_id = poly_data.insert_unique_point(DmDPoint(0.0, 0.0, 0.0))
+        ```
+        """
+        return self._obj.InsertUniquePoint(point._obj)
+
+    def get_point(self, point_id: int) -> DmDPoint:
+        """
+        根据ID获取点
+        :param point_id: 点的唯一ID（整数）
+        :return: 对应的DmDPoint实例
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        point_id = poly_data.insert_unique_point(DmDPoint(0.0, 0.0, 0.0))
+        point = poly_data.get_point(point_id)
+        ```
+        """
+        cpp_point = self._obj.GetPoint(point_id)
+        return DmDPoint._from_obj(cpp_point)
+
+    def set_dm_points(self, points: DmPoints) -> None:
+        """
+        设置关联的点集合
+        :param points: DmPoints实例
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        points = DmPoints()
+        poly_data.set_dm_points(points)
+        ```
+        """
+        self._obj.SetDmPoints(points._obj)
+
+    def get_dm_points(self) -> DmPoints:
+        """
+        获取关联的点集合
+        :return: DmPoints实例
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        points = DmPoints()
+        poly_data.set_dm_points(points)
+        dm_points = poly_data.get_dm_points()
+        ```
+        """
+        cpp_points = self._obj.GetDmPoints()
+        return DmPoints._from_obj(cpp_points)
+
+    # ---------------------- 多边形数据获取 ----------------------
+    def get_poly_cell(self, cell_index: int) -> list[int]:
+        """
+        获取指定索引的多边形单元格的点索引
+        :param cell_index: 单元格索引（整数）
+        :return: 点索引列表（整数列表）
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        cell_index = 0
+        point_indexes = poly_data.get_poly_cell(cell_index)
+        ```
+        """
+        return self._obj.GetPolyCell(cell_index)
+
+    # ---------------------- 提取多段线 ----------------------
+    def extract_polylines(self) -> list[DmDbPolyline]:
+        """
+        提取多段线实体
+        :return: 多段线列表，每个元素为DmDbPolyline实例
+
+        example:
+        ```python
+        poly_data = DmPolyData()
+        polylines = poly_data.extract_polylines()
+        ```
+        """
+        cpp_list = self._obj.ExtractPolylines()
+        return [DmDbPolyline._from_obj(item) for item in cpp_list]
+
+    # ---------------------- 字符串表示 ----------------------
+    def __repr__(self) -> str:
+        """
+        字符串表示
+        :return: 多边形数据的标准字符串表示
+        """
+        return self._obj.__repr__()
+
+    # ---------------------- 桥接方法 ----------------------
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        原生对象创建封装实例
+        :param obj: 原生dmPolyData对象
+        :return: DmPolyData实例
+        """
+        instance = cls.__new__(cls)
+        instance._obj = obj
+        return instance
+
+#几何实体基类
+class DmDbEntity:
+    """所有实体对象都继承自该类，包括获取实体类型函数GetType、
+    将三维实体转换到dmPolyData对象函数ToPolyData、
+    将对象转换为三维实体对象函数ConvertToShell、
+    将对象转换为三维多段线对象函数ConvertToPolyline、
+    将对象转换为直线对象函数ConvertToLine、
+    将对象转换为点对象函数ConvertToPoint、
+    设置实体颜色函数SetColor、
+    获取实体类型名称函数GetEntityTypeName、
+    获取实体名称函数GetEntityName等
+
+    example:
+    ```python
+    dmf = DmDbDatabase()
+    db = dmf.load('E:/dassistant/tests/123.dmf')
+    print("获取图层数量:",dmf.get_layers_count())
+    act_layer = dmf.get_active_layer()
+
+    layerCount = dmf.get_layers_count()
+    for i in range(layerCount):
+        layer = dmf.get_layer_by_index(i)
+        if layer is None:
+            continue
+
+        print("图层实体数量:",layer.get_entities_count())
+
+        layer.start_query_entity()
+        entity = layer.open_next_entity()
+        while entity is not None:
+            nType = entity.get_type()
+            #print("实体类型:",nType)
+            if nType == EntityType.ETT_POLYLINE:
+                print("实体类型名称:", entity.get_entity_type_name())
+                polydata = entity.to_poly_data()
+                print("获取多边形点集:",polydata.get_dm_points())
+                print("获取多边形包围盒:",polydata.get_bounds())
+            elif nType == EntityType.ETT_POINT:
+                print("实体类型名称:", entity.get_entity_type_name())
+                point = entity.convert_to_point().get_graph_data()
+                print(type(point))
+                print("获取点数据:",point)
+            elif nType == EntityType.ETT_LINE:
+                print("实体类型名称:", entity.get_entity_type_name())
+                line = entity.convert_to_line()
+                print(type(line))
+                print("获取线数据:",line)
+                entity.set_color(255,0,0)
+            entity = layer.open_next_entity()
+    ```
+    """
+
+    # def __init__(self):
+    #     self._obj = None
+
+
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        原生DmDbEntity对象创建封装实例
+        :param obj: 原生DmDbEntity对象（bind11封装后）
+        :return: DmDbEntity实例
+        """
+        instance = cls.__new__(cls)
+        instance._obj = obj
+        return instance
+
+    def get_type(self) -> int:
+        """
+        获取实体类型编码
+        :return: 实体类型的整数编码
+        """
+        return self._obj.GetType()
+
+    def to_poly_data(self) -> DmPolyData:
+        """
+        将实体转换为多边形数据
+        :return: 转换后的DmPolyData实例（需提前实现该类及_from_obj方法）
+        """
+        cpp_result = self._obj.ToPolyData()
+        return DmPolyData._from_obj(cpp_result)
+
+    def convert_to_shell(self) -> DmDbShell:
+        """
+        将实体转换为Shell对象
+        :return: 转换后的DmDbShell实例
+        """
+        cpp_result = self._obj.ConvertToShell()
+        return DmDbShell._from_obj(cpp_result)
+
+    def convert_to_polyline(self) -> DmDbPolyline:
+        """
+        将实体转换为多段线对象
+        :return: 转换后的DmDbPolyline实例
+        """
+        cpp_result = self._obj.ConvertToPolyline()
+        return DmDbPolyline._from_obj(cpp_result)
+
+    def convert_to_line(self) -> DmDbLine:
+        """
+        将实体转换为线对象
+        :return: 转换后的DmDbLine实例
+        """
+        cpp_result = self._obj.ConvertToLine()
+        return DmDbLine._from_obj(cpp_result)
+
+    def convert_to_point(self) -> DmDbPoint:
+        """
+        将实体转换为点对象
+        :return: 转换后的DmDbPoint实例
+        """
+        cpp_result = self._obj.ConvertToPoint()
+        return DmDbPoint._from_obj(cpp_result)
+
+    def set_color(self, red: int, green: int, blue: int) -> None:
+        """
+        设置实体颜色
+        :param red: 红色分量（0-255）
+        :param green: 绿色分量（0-255）
+        :param blue: 蓝色分量（0-255）
+
+        example:
+        ```python
+        entity = DmDbEntity()
+        entity.set_color(255, 0, 0)
+        ```
+        """
+        self._obj.SetColor(red, green, blue)
+
+    def get_entity_type_name(self) -> str:
+        """
+        获取实体类型名称（UTF-8编码）
+        :return: 实体类型名称字符串
+
+        example:
+        ```python
+        entity = DmDbEntity()
+        entity_type_name = entity.get_entity_type_name()
+        ```
+        """
+        return self._obj.GetEntityTypeName()
+
+    def get_entity_name(self) -> str:
+        """
+        获取实体名称（UTF-8编码）
+        :return: 实体名称字符串
+
+        example:
+        ```python
+        entity = DmDbEntity()
+        entity_name = entity.get_entity_name()
+        ```
+        """
+        return self._obj.GetEntityName()
+
+
+# 工作面实体
+class DmDbWorkPlane:
+    def __init__(self):
+        """
+        构造工作平面
+        """
+        self._obj = Dm.dmDbWorkPlane()
+
+    def set_normal(self, normal: DmDPoint) -> None:
+        """设置法向量"""
+        self._obj.SetNormal(normal._obj)
+
+    def set_origin(self, origin: DmDPoint) -> None:
+        """设置原点"""
+        self._obj.SetOrigin(origin._obj)
+
+    def set_x_axis(self, x_axis: DmDPoint) -> None:
+        """设置X轴方向"""
+        self._obj.SetXAxis(x_axis._obj)
+
+    def set_y_axis(self, y_axis: DmDPoint) -> None:
+        """设置Y轴方向"""
+        self._obj.SetYAxis(y_axis._obj)
+
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        原生dmDbWorkPlane对象创建封装实例
+        :param obj: 原生dmDbWorkPlane对象（bind11封装后）
+        :return: DmDbWorkPlane实例
+        """
+        instance = cls.__new__(cls)
+        instance._obj = obj
+        return instance
+
+
+class DmDbLayer:
+    def __init__(self):
+        self._obj = Dm.dmDbLayer()
+
+    def start_query_entity(self) -> None:
+        """
+        开始查询实体
+
+        example:
+        ```python
+        dmf = DmDbDatabase()
+        db = dmf.load('E:/dassistant/tests/123.dmf')
+        print("获取图层数量:",dmf.get_layers_count())
+        act_layer = dmf.get_active_layer()
+
+        layerCount = dmf.get_layers_count()
+        for i in range(layerCount):
+            layer = dmf.get_layer_by_index(i)
+            if layer is None:
+                continue
+
+            print("图层实体数量:",layer.get_entities_count())
+
+            layer.start_query_entity()
+            entity = layer.open_next_entity()
+            while entity is not None:
+                nType = entity.get_type()
+                #print("实体类型:",nType)
+                if nType == EntityType.ETT_POLYLINE:
+                    ···
+                entity = layer.open_next_entity()
+        ```
+        """
+        self._obj.StartQueryEntity()
+
+    def get_entities_count(self) -> int:
+        """获取实体数量"""
+        return self._obj.GetEntitiesCount()
+
+    def open_next_entity(self) -> Optional[DmDbEntity]:
+        """打开下一个实体，返回封装后的实体对象，无实体时返回 None"""
+        raw_entity = self._obj.OpenNextEntity()
+        if raw_entity:
+            return DmDbEntity._from_obj(raw_entity)
+        return None
+
+    def insert_entity(self, entity: Union[DmDbEntity, DmDbPolyline]) -> None:
+        """插入实体，支持 DmDbEntity 和 dmDbPolyline 类型"""
+        self._obj.InsertEntity(entity._obj)
+
+    def insert_polyline(self, points: List[DmDPoint]) -> DmDbEntity:
+        """插入多段线，返回封装后的实体对象"""
+        cpp_points = [p._obj for p in points]
+        raw_entity = self._obj.InsertPolyline(cpp_points)
+        return DmDbEntity._from_obj(raw_entity)
+
+    def insert_line(self, start: DmDPoint, end: DmDPoint) -> DmDbEntity:
+        """插入直线，返回封装后的实体对象"""
+        raw_entity = self._obj.InsertLine(start._obj, end._obj)
+        return DmDbEntity._from_obj(raw_entity)
+
+    def set_work_plane_entity(self, work_plane: DmDbWorkPlane) -> None:
+        """设置工作平面实体"""
+        self._obj.SetWorkPlaneEntity(work_plane._obj)
+
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        原生dmDbLayer对象创建封装实例
+        :param obj: 原生dmDbLayer对象（bind11封装后）
+        :return: DmDbLayer实例
+        """
+        instance = cls.__new__(cls)
+        instance._obj = obj
+        return instance
+
+
+class DmDbDatabase:
+    """
+    几何数据库
+    """
+
+    def __init__(self):
+        # 初始化源扩展的核心对象，作为底层操作入口
+        self._db = Dm.dmDbDatabase()
+
+    def load(self, file_path: str) -> bool | int:
+        """
+        加载本地数据库文件（底层调用源Load接口）
+        :param file_path: 数据库文件路径（UTF-8编码，底层已处理编码转换）
+        :return: 加载结果，成功返回True/0，失败返回False/错误码
+
+        example:
+        ```python
+        dmf = DmDbDatabase()
+        db = dmf.load('E:/dassistant/tests/123.dmf')
+        print(db)
+        ```
+        """
+        if not isinstance(file_path, str) or not file_path.strip():
+            raise ValueError("文件路径不能为空字符串")
+        return self._db.Load(file_path)
+
+    def get_layers_count(self) -> int:
+        """
+        获取数据库图层总数（底层调用源GetLayersCount接口）
+        :return: 非负整数，图层总数量
+
+        example:
+        ```python
+        dmf = DmDbDatabase()
+        db = dmf.load('E:/dassistant/tests/123.dmf')
+        print("获取图层数量:",dmf.get_layers_count())
+        ```
+        """
+        return self._db.GetLayersCount()
+
+    def get_layer_by_index(self, layer_index: int) -> DmDbLayer | None:
+        """
+        通过索引获取图层对象（底层调用源GetLayerFromIndex接口）
+        :param layer_index: 图层索引，从0开始
+        :return: 图层对象，索引无效时返回None
+        """
+        if not isinstance(layer_index, int) or layer_index < 0:
+            raise ValueError("图层索引必须为非负整数")
+        cpp_result = self._db.GetLayerFromIndex(layer_index)
+        return DmDbLayer._from_obj(cpp_result)
+
+    def set_file_name(self, file_path: str) -> None:
+        """
+        设置数据库文件路径（底层调用源SetFileName接口）
+        :param file_path: 数据库文件路径（UTF-8编码）
+        """
+        if not isinstance(file_path, str) or not file_path.strip():
+            raise ValueError("文件路径不能为空字符串")
+        self._db.SetFileName(file_path)
+
+    def insert_layer(self, layer_name: str) -> DmDbLayer:
+        """
+        插入新图层（底层调用源InsertLayer接口）
+        :param layer_name: 图层名称（UTF-8编码）
+        :return: 新创建的图层对象
+
+        example:
+        ```python
+        dmf = DmDbDatabase()
+        db = dmf.load('E:/dassistant/tests/123.dmf')
+        layer = dmf.insert_layer("新图层")
+        print("插入新图层:",layer)
+        ```
+        """
+        if not isinstance(layer_name, str) or not layer_name.strip():
+            raise ValueError("图层名称不能为空字符串")
+        cpp_result = self._db.InsertLayer(layer_name.strip())
+        return DmDbLayer._from_obj(cpp_result)
+
+    def save(self, file_path: str | None = None) -> bool | int:
+        """
+        保存数据库（底层调用源Save重载接口，自动适配无参/有参）
+        :param file_path: 可选保存路径，为None时保存到当前路径
+        :return: 保存结果，成功返回True/0，失败返回False/错误码
+
+        example:
+        ```python
+        dmf = DmDbDatabase()
+        db = dmf.load('E:/dassistant/tests/123.dmf')
+        layer = dmf.insert_layer("新图层")
+        print("插入新图层:",layer)
+        dmf.save("E:/dassistant/tests/123_1.dmf")
+        ```
+        """
+        if file_path is None:
+            return self._db.Save()
+        if not isinstance(file_path, str) or not file_path.strip():
+            raise ValueError("保存路径不能为空字符串")
+        return self._db.Save(file_path)
+
+    def switch_to_local_storage(self) -> None:
+        """切换到本地存储模式（底层调用源SetToLocalStorage接口）"""
+        self._db.SetToLocalStorage()
+
+    def get_active_layer(self) -> DmDbLayer | None:
+        """
+        获取当前激活图层（底层调用源GetActiveLayer接口）
+        :return: 激活图层对象，无激活图层时返回None
+
+        example:
+        ```python
+        dmf = DmDbDatabase()
+        db = dmf.load('E:/dassistant/tests/123.dmf')
+        layer = dmf.get_active_layer()
+        print("当前活动图层:",layer)
+        ```
+        """
+        cpp_result = self._db.GetActiveLayer()
+        return DmDbLayer._from_obj(cpp_result)
+
+    @staticmethod
+    def create_local_db() -> "DmDbDatabase":
+        """
+        创建本地数据库（底层调用源CreateLocalDB静态接口）
+        :return: 新创建的数据库对象
+        """
+        cpp_db = Dm.dmDbDatabase.CreateLocalDB()
+        return DmDbDatabase._from_obj(cpp_db)
+
+    def close_polyline(self) -> bool | int:
+        """
+        闭合多段线（底层调用源ClosePolyline接口）
+        :return: 操作结果
+        """
+        return self._db.ClosePolyline()
+
+    def set_color(self, red: int, green: int, blue: int) -> None:
+        """
+        设置颜色（底层调用源SetColor接口）
+        :param red: 红色通道值（0-255）
+        :param green: 绿色通道值（0-255）
+        :param blue: 蓝色通道值（0-255）
+        """
+        if not (0 <= red <= 255) or not (0 <= green <= 255) or not (0 <= blue <= 255):
+            raise ValueError("颜色值必须在0-255之间")
+        self._db.SetColor(red, green, blue)
+
+    def add_property(self, property_name: str, property_type: str) -> tuple[bool, str]:
+        """
+        添加属性（底层调用源AddProperty接口）
+        :param property_name: 属性名称（UTF-8编码）
+        :param property_type: 属性类型（UTF-8编码）
+        :return: 操作结果（是否成功，提示信息）
+        """
+        if not isinstance(property_name, str) or not property_name.strip():
+            raise ValueError("属性名称不能为空")
+        if not isinstance(property_type, str):
+            raise ValueError("属性类型必须为字符串")
+        return self._db.AddProperty(property_name, property_type)
+
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        原生dmDbDatabase对象创建封装实例
+        :param obj: 原生dmDbDatabase对象（bind11封装后）
+        :return: DmDbDatabase实例
+        """
+        instance = cls.__new__(cls)
+        instance._obj = obj
+        return instance
+
+
+class DmDataTableRecord:
+    """
+    数据表记录类
+    """
+
+    # def __init__(self, record_obj: Dm.CDataTableRecord):
+    #     self._obj = record_obj  # 接收底层记录对象
+
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        原生dmDataTableRecord对象创建封装实例
+        :param obj: 原生dmDataTableRecord对象（bind11封装后）
+        :return: DmDataTableRecord实例
+        """
+        instance = cls.__new__(cls)
+        instance._obj = obj
+        return instance
+
+    def as_string(self, field_name: str) -> str:
+        """
+        获取字段值（字符串形式）
+        :param field_name: UTF-8 编码的字段名
+        :return: 字段值字符串
+        """
+        if not isinstance(field_name, str) or not field_name.strip():
+            raise ValueError("字段名不能为空字符串")
+        return self._obj.asString(field_name)
+
+    def as_double(self, field_name: str) -> float:
+        """
+        获取字段值（浮点形式）
+        :param field_name: UTF-8 编码的字段名
+        :return: 字段值浮点数
+        """
+        if not isinstance(field_name, str) or not field_name.strip():
+            raise ValueError("字段名不能为空字符串")
+        return self._obj.asDouble(field_name)
+
+    def set_value(self, field_name: str, value: str | float) -> None:
+        """
+        设置字段值（支持字符串/浮点数）
+        :param field_name: UTF-8 编码的字段名
+        :param value: 字段值（字符串或浮点数）
+        """
+        if not isinstance(field_name, str) or not field_name.strip():
+            raise ValueError("字段名不能为空字符串")
+        if isinstance(value, str):
+            self._obj.Set_Value(field_name, value)
+        elif isinstance(value, (int, float)):
+            self._obj.Set_Value(field_name, float(value))
+        else:
+            raise TypeError("字段值仅支持字符串或数字类型")
+
+
+class DmDataTable:
+    """
+    数据表 Python 二次封装类
+    """
+
+    def __init__(self):
+        self._obj = Dm.CDataTable()
+
+    def load(self, file_path: str) -> bool | int:
+        """
+        加载数据表文件
+        :param file_path: UTF-8 编码的数据表文件路径
+        :return: 加载结果（成功返回 True/0，失败返回 False/错误码）
+
+        example:
+        ```python
+        dt = DmDataTable()
+        dt.load("E:/dassistant/tests/123.dmd")
+        print("字段总数:",dt.get_field_count())
+        ```
+        """
+        if not isinstance(file_path, str) or not file_path.strip():
+            raise ValueError("文件路径不能为空字符串")
+        return self._obj.Load(file_path)
+
+    def get_field_count(self) -> int:
+        """获取字段总数"""
+        return self._obj.Get_Field_Count()
+
+    def get_record_count(self) -> int:
+        """获取记录总数"""
+        return self._obj.Get_Record_Count()
+
+    def get_record_data(self, record_index: int) -> dict:
+        """
+        通过索引获取单条记录的完整数据
+        :param record_index: 记录索引（从0开始）
+        :return: 记录数据字典，键为字段名，值为字段值
+        """
+        return self._obj.Get_Record_Data(record_index)
+
+    def get_field_id(self, field_name: str) -> int:
+        """
+        通过字段名获取字段ID
+        :param field_name: UTF-8 编码的字段名
+        :return: 字段ID
+        """
+        if not isinstance(field_name, str) or not field_name.strip():
+            raise ValueError("字段名不能为空字符串")
+        return self._obj.Get_Field_Id(field_name)
+
+    def get_field_name(self, field_index: int) -> str:
+        """
+        通过索引获取字段名
+        :param field_index: 字段索引（从0开始）
+        :return: UTF-8 编码的字段名
+        """
+        # if not isinstance(field_index, int) or field_index < 0:
+        #     raise ValueError("字段索引必须为非负整数")
+        # if field_index >= self.get_field_count():
+        #     raise IndexError("字段索引超出范围")
+        return self._obj.Get_Field_Name(field_index)
+
+    def get_field_display_name(self, field_index: int) -> str:
+        """
+        通过索引获取字段显示名
+        :param field_index: 字段索引（从0开始）
+        :return: UTF-8 编码的字段显示名
+        """
+        # if not isinstance(field_index, int) or field_index < 0:
+        #     raise ValueError("字段索引必须为非负整数")
+        # if field_index >= self.get_field_count():
+        #     raise IndexError("字段索引超出范围")
+        return self._obj.Get_Field_DisplayName(field_index)
+
+    def get_field_type(self, field_index: int) -> int:
+        """
+        通过索引获取字段类型
+        :param field_index: 字段索引（从0开始）
+        :return: 字段类型枚举值
+        """
+        # if not isinstance(field_index, int) or field_index < 0:
+        #     raise ValueError("字段索引必须为非负整数")
+        # if field_index >= self.get_field_count():
+        #     raise IndexError("字段索引超出范围")
+        return self._obj.Get_Field_Type(field_index)
+
+    def get_record_from_index(self, record_index: int) -> DmDataTableRecord:
+        """
+        通过索引获取原始记录对象
+        :param record_index: 记录索引（从0开始）
+        :return: 原始记录对象
+        """
+        # if not isinstance(record_index, int) or record_index < 0:
+        #     raise ValueError("记录索引必须为非负整数")
+        # if record_index >= self.get_record_count():
+        #     raise IndexError("记录索引超出范围")
+        cpp_result = self._obj.Get_Record_From_Index(record_index)
+        return DmDataTableRecord._from_obj(cpp_result)
+
+    def get_record_count_by_condition(self, field_name: str, field_value: str) -> int:
+        """
+        根据字段名和值筛选记录数量
+        :param field_name: UTF-8 编码的字段名
+        :param field_value: UTF-8 编码的字段值
+        :return: 符合条件的记录数量
+        """
+        if not isinstance(field_name, str) or not field_name.strip():
+            raise ValueError("字段名不能为空字符串")
+        if not isinstance(field_value, str):
+            raise ValueError("字段值必须为字符串")
+        return self._obj.GetRecordCountByCondition(field_name, field_value)
+
+    def add_record(self) -> bool | int:
+        """添加一条新记录"""
+        return self._obj.Add_Record()
+
+    def save(self) -> bool | int:
+        """保存数据表"""
+        return self._obj.Save()
+
+    @classmethod
+    def _from_obj(cls, obj):
+        """
+        原生dmDataTable对象创建封装实例
+        :param obj: 原生dmDataTable对象（bind11封装后）
+        :return: DmDataTable实例
+        """
+        instance = cls.__new__(cls)
+        instance._obj = obj
+        return instance