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

dimine_python_sdk/__init__.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+from .conn import ConnClient
+
+DOCS_PATH = Path(__file__).parent / "docs"
+__VERSION__ = "0.1.8"  # 由 build.bat 中的 generate_version.py 自动更新
+
+
+__all__ = [
+    "ConnClient",
+    "DOCS_PATH",
+    "__VERSION__"
+]

dimine_python_sdk/conn/__init__.py

@@ -0,0 +1,5 @@
+from .conn_client import ConnClient
+from .conn_client import open_client
+
+__all__ = ["ConnClient", "open_client"]
+

dimine_python_sdk/conn/base_conn_client.py

@@ -0,0 +1,167 @@
+
+import asyncio
+from dataclasses import dataclass,field
+import inspect
+import json
+from dimine_python_sdk.logger import logger
+from typing import Any, Dict, List, Optional, Tuple, Callable
+import websockets
+import traceback
+
+from dimine_python_sdk.models.conn import ConnEvent, ConnRequest, ConnResponse,CommandType
+from dimine_python_sdk.models.errors import ResponseError
+
+@dataclass
+class BaseConnClient:
+    model_config = {"arbitrary_types_allowed": True}
+
+    url: Optional[str] = "ws://localhost:8000"
+    is_connected: Optional[bool] = False
+    pending_requests: Dict[str, Tuple[asyncio.Future, Callable]] = field(default_factory=dict)
+    event_handlers: Dict[str, List[Callable]] = field(default_factory=dict)
+    reconnect_delay: int = 2
+    max_reconnect_attempts: int = 5
+    reconnect_attempts: int = 0
+    websocket: websockets.connect = None
+    receive_task: Optional[asyncio.Task] = None
+
+    async def _handle_message(self, message: str):
+        """处理接收到的消息"""
+        try:
+            data = json.loads(message)
+        except json.JSONDecodeError:
+            logger.error(f"unable parse message: {message}")
+        try:
+            message_type = data.get("type")
+            
+            if message_type == "response":
+                res = ConnResponse(**data)
+                # 处理响应消息
+                request_id = res.request_id
+                if request_id in self.pending_requests:
+                    future,callback = self.pending_requests.pop(request_id)
+                    future.set_result(res)
+                    if callback:
+                        callback(res)
+            
+            elif message_type == "event":
+                event = ConnEvent(**data)
+                await self._handle_event(event)
+        except Exception as e:
+            logger.error(f"error in handle message: {traceback.format_exc()}")
+
+    async def _handle_event(self, event: ConnEvent):
+        """处理事件"""
+        if event.event_type in self.event_handlers:
+            tasks = []
+            for handler in self.event_handlers.get(event.event_type, []):
+                if inspect.iscoroutinefunction(handler):
+                    t_handler = handler(event)
+                    tasks.append(t_handler)
+                else:
+                    t_handler = asyncio.to_thread(handler, event)
+                    tasks.append(t_handler)
+            await asyncio.gather(*tasks)
+        else:
+            logger.info(f"no handler for event type : {event.event_type}")
+
+
+    async def _receive_messages(self):
+        while self.is_connected:
+            try:
+                message = await self.websocket.recv()
+                await self._handle_message(message)
+            except websockets.exceptions.ConnectionClosed:
+                logger.error("WebSocket connection closed")
+                self.is_connected = False
+                await self._reconnect()
+            except Exception as e:
+                logger.error(f"error in receive or handle message: {e}")
+
+
+    async def connect(self)-> bool:
+        try:
+            self.websocket = await websockets.connect(self.url)
+            self.is_connected = True
+            self.reconnect_attempts = 0
+            logger.info("success connected to %s", self.url)
+            if self.receive_task is None or self.receive_task.done():
+                self.receive_task = asyncio.create_task(self._receive_messages())
+            return True
+        except Exception as e:
+            logger.error("failed to connect to %s: %s", self.url, e)
+            self.is_connected = False
+            self.reconnect_attempts += 1
+            if self.reconnect_attempts < self.max_reconnect_attempts:
+                await asyncio.sleep(self.reconnect_delay)
+                return await self.connect()
+            return False
+
+
+    async def _reconnect(self)->bool:
+        """重新连接到服务器"""
+        if self.reconnect_attempts < self.max_reconnect_attempts:
+            self.reconnect_attempts += 1
+            logger.info(f"try to reconnect ({self.reconnect_attempts}/{self.max_reconnect_attempts})...")
+            await asyncio.sleep(self.reconnect_delay)
+            return await self.connect()
+        else:
+            logger.error("max reconnect attempts reached")
+            return False
+
+    async def _send_request(self, request: ConnRequest, callback: Callable = None)->ConnResponse:
+        if not self.is_connected:
+            logger.error("websocket not connected, try to reconnect")
+            if not await self.connect():
+                raise Exception("failed to reconnect websocket")
+        future = asyncio.Future()
+        self.pending_requests[request.request_id] = (future, callback)
+        try:
+            # 发送请求
+            await self.websocket.send(request.model_dump_json())
+        except Exception as e:
+            # 移除pending请求
+            if request.request_id in self.pending_requests:
+                self.pending_requests.pop(request.request_id)
+            raise e
+        else:
+            result = await future
+            return result
+        
+    async def send_request(self, command: CommandType, payload:Optional[Any]=None,  callback: Optional[Callable] = None)->ConnResponse:
+        """发送请求并等待响应"""
+        request = ConnRequest(command=command, payload=payload)
+        return await self._send_request(request, callback)
+
+    async def close(self):
+        """关闭WebSocket连接"""
+        if self.is_connected:
+            self.is_connected = False
+            if self.websocket:
+                try:
+                    await self.websocket.close()
+                except:
+                    pass
+            if self.receive_task and not self.receive_task.done():
+                self.receive_task.cancel()
+            logger.info("WebSocket closed.")
+        
+
+    def on_event(self, event_type: str, handler: Optional[Callable] = None):
+        """注册事件处理器，支持装饰器语法"""
+        # 如果提供了handler参数，直接注册
+        if handler is not None:
+            if event_type not in self.event_handlers:
+                self.event_handlers[event_type] = []
+            self.event_handlers[event_type].append(handler)
+            return handler
+        
+        # 否则返回装饰器函数
+        def decorator(func: Callable) -> Callable:
+            if event_type not in self.event_handlers:
+                self.event_handlers[event_type] = []
+            self.event_handlers[event_type].append(func)
+            return func
+        
+        return decorator
+    

dimine_python_sdk/conn/conn_client.py

@@ -0,0 +1,382 @@
+
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any, AsyncGenerator, Dict, List, Optional
+import numpy as np
+from dimine_python_sdk.conn.base_conn_client import BaseConnClient
+from dimine_python_sdk.models import FileInfo, ResponseStatus, CommandType,LayerInfo, FeatureInfo
+
+from dimine_python_sdk.models.types import GEOMETRY, Line, Point, Shell
+
+
+class ConnClient(BaseConnClient):
+
+    async def get_files(self) -> List[FileInfo]:
+        """获取文件对象树"""
+        res = await self.send_request(CommandType.GET_FILE_TREE)
+        if res.status == ResponseStatus.FAIL:
+            raise Exception(res.error)
+        return [FileInfo(**item, related=True) for item in res.payload]
+    
+    async def close_file(self, file_id: str):
+        """关闭文件"""
+        res = await self.send_request(CommandType.FILE_CLOSE, {"file": file_id})
+        if res.status == ResponseStatus.FAIL:
+            raise Exception(res.error)
+    
+    async def open_file(self, file_path: str| Path) -> FileInfo:
+        """打开文件"""
+        if isinstance(file_path, str):  # 如果是 str 对象，则转换为 Path
+            file_path = Path(file_path)
+            if not file_path.exists():  # 如果文件不存在，报错
+                raise Exception(f"file {file_path} not exists")
+        res = await self.send_request(CommandType.FILE_OPEN, {"file_path": str(file_path)})
+        if res.status == ResponseStatus.FAIL:
+            raise Exception(res.error)
+        print("res.payload: ", res.payload)
+        if res.payload:
+            return FileInfo(id=res.payload[0].get("file_id"), name=res.payload[0].get("file_id"), related=True)
+        else:
+            raise Exception("file already opened!")
+
+    
+    async def export_file(self, file_id: str, file_path: str| Path, mkdir: bool = True):
+        """导出文件
+
+        Args:
+            file_id: 文件ID或文件名称
+            file_path: 导出目标路径
+            mkdir: 是否自动创建目录
+        Raises:
+            Exception: 导出失败时抛出异常
+        """
+        if isinstance(file_path, str):  # 如果是 str 对象，则转换为 Path
+            file_path = Path(file_path)
+            if not file_path.parent.exists():  # 如果目录不存在，报错
+                if mkdir:
+                    file_path.parent.mkdir(parents=True, exist_ok=True)
+                else:
+                    raise Exception(f"path {file_path.parent} not exists")
+        res = await self.send_request(CommandType.FILE_EXPORT, {"file": file_id, "file_path": str(file_path)})
+        if res.status == ResponseStatus.FAIL:
+            raise Exception(res.error)
+
+# 模型相关方法
+    async def create_geometry(self, geometries: List[GEOMETRY]) -> None:
+        """创建模型
+
+        Args:
+            geometries: 模型列表，每个模型包含以下字段:
+                - file: 文件名称
+                - layer: 图层名称
+                - feature: 要素列名称
+                - entity_type: "point | line | polyline | shell"
+                - geometry: 几何信息 (coordinates)
+                - properties: 属性信息列表
+                - color: 颜色 [R, G, B]
+
+        Raises:
+            Exception: 创建失败时抛出异常
+        """
+        # 格式化模型数据
+        formatted_geometries = []
+        for geom in geometries:
+            formatted_geom = {
+                "file": geom.file,
+                "layer": geom.layer,
+                "feature": geom.feature,
+                "entity_type": geom.type,
+                "geometry": geom.geometry.astype("str").tolist() if geom.type!="shell" else {"indexs": geom.geometry.faces.tolist(), "points": geom.geometry.points.astype("str").tolist()},
+                "color": geom.color,
+            }
+
+            # 处理属性信息
+            formatted_geom["properties"] = [
+                    {"name": prop.name, "value": prop.value}
+                    for prop in geom.properties
+                ]
+
+            formatted_geometries.append(formatted_geom)
+        response = await self.send_request(CommandType.CREATE_GEOMETRY, formatted_geometries)
+        if response.status == ResponseStatus.FAIL:
+            raise Exception(response.error)
+        # 更新id等信息
+        for i, item in enumerate(response.payload):
+            geometries[i].id=item.get("id")
+            geometries[i].related=True
+        
+    
+    async def get_geometry(self, file_id: str, layer_id: str, entity_types: List[str]=[], features: Optional[List[str]] = None) -> List[GEOMETRY]:
+        """获取模型"""
+        # 先获取要素信息，
+        all_features = await self.get_features(file_id)
+
+        def _get_property_type(feature_name:str, name: str)-> str:
+            """获取属性类型"""
+            for feature in all_features:
+                if feature.name == feature_name:
+                    for property in feature.properties:
+                        if property.name == name:
+                            return property.type
+
+        payload = {
+            "file": file_id,
+            "layer": layer_id,
+            "entity_type": entity_types
+        }
+        if features:
+            payload["feature"] = features
+        
+        response = await self.send_request(CommandType.GET_GEOMETRY, payload)
+        if response.status == ResponseStatus.FAIL:
+            raise Exception(response.error)
+        
+        def _format_value(type:str, value: Any):
+            if value == "" and type != "string":
+                return None
+            elif type == "double":
+                return float(value)
+            elif type == "string":
+                return str(value)
+            elif type in ["int","long","short"]:
+                return int(value)
+            else:
+                raise Exception(f"unknown property type: {type}")
+
+        def _handle_property(feature_name:str, properties: List[Dict[str, Any]]):
+            for property in properties:
+                property["type"] = _get_property_type(feature_name, property.get("name"))
+                property["value"] = _format_value(property.get("type"), property.get("value"))
+
+        geometries = []
+        for item in response.payload:
+            _handle_property(item.get("feature"), item.get("properties", []))
+            if isinstance(item.get("geometry", []), list):
+                tdata = np.asarray(item.get("geometry", [])).astype(np.float64)
+                if len(tdata.shape) == 1:
+                    item["geometry"] = tdata
+                    geometries.append(Point(**item, related=True))
+                elif len(tdata.shape) == 2:
+                    geometries.append(Line(**item, related=True))
+            elif isinstance(item.get("geometry", []), dict):
+                item["geometry"]["faces"] = item["geometry"].pop("indexs") if "indexs" in item["geometry"] else []
+                geometries.append(Shell(**item, related=True))
+        for geom in geometries:
+            geom.file = file_id
+            geom.layer = layer_id
+        return geometries
+    
+    async def update_geometry(self, geometries: List[GEOMETRY]) -> None:
+        """更新模型
+
+        Args:
+            geometries: 模型列表，每个模型包含以下字段:
+                - id: 模型ID (句柄ID)
+                - layer: 图层名称
+                - entity_type: "point | line | polyline | shell"
+                - geometry: 模型几何信息 (可选)
+                - properties: 模型属性信息 (可选)
+                - color: 颜色 [R, G, B] (可选)
+                - feature: 模型关联要素列表 (可选)
+
+        Raises:
+            Exception: 更新失败时抛出异常
+        """
+        # 格式化模型数据
+        formatted_geometries = []
+        for geom in geometries:
+            formatted_geom = {
+                "id": geom.id,
+                "file": geom.file,
+                "layer": geom.layer,
+                "feature": geom.feature,
+                "entity_type": geom.type,
+                "geometry": geom.geometry.astype("str").tolist() if geom.type!="shell" else {"indexs": geom.geometry.faces.tolist(), "points": geom.geometry.points.astype("str").tolist()},
+                "color": geom.color,
+            }
+
+            # 处理属性信息
+            formatted_geom["properties"] = [
+                    {"name": prop.name, "value": prop.value}
+                    for prop in geom.properties
+                ]
+            formatted_geometries.append(formatted_geom)
+
+        response = await self.send_request(CommandType.UPDATE_GEOMETRY, formatted_geometries)
+        if response.status == ResponseStatus.FAIL:
+            raise Exception(response.error)
+
+    async def delete_geometry(self, delete_items: List[Dict[str, str]]) -> None:
+        """删除模型
+
+        Args:
+            delete_items: 删除项列表，每个项包含:
+                - id: 模型ID (句柄ID)
+                - file: 文件ID (从哪个文件删除模型)
+
+        Raises:
+            Exception: 删除失败时抛出异常
+        """
+        response = await self.send_request(CommandType.DELETE_GEOMETRY, delete_items)
+        if response.status == ResponseStatus.FAIL:
+            raise Exception(response.error)
+
+
+
+    async def update_or_create_geometry(self, geometries: List[GEOMETRY] | GEOMETRY) -> None:
+        """创建或更新多个模型, 如果指定了file_id和layer_id, 则将模型添加到指定的文件及图层中"""
+        update_geometries = [g for g in geometries if g.related]
+        create_geometries = [g for g in geometries if not g.related]
+        if update_geometries:
+            await self.update_geometry(update_geometries)
+        if create_geometries:
+            await self.create_geometry(create_geometries)
+
+
+    # 图层相关方法
+    async def create_layer(self, file_id: str, name: str) -> LayerInfo:
+        """创建图层
+
+        Args:
+            file_id: 文件ID或文件名称
+            name: 图层名称
+
+        Returns:
+            创建的图层信息
+
+        Raises:
+            Exception: 创建失败时抛出异常
+        """
+        payload = {
+            "file": file_id,
+            "name": name
+        }
+        response = await self.send_request(CommandType.CREATE_LAYER, payload)
+        if response.status == ResponseStatus.FAIL:
+            raise Exception(response.error)
+        return LayerInfo(id=name, name=name, related=True)
+
+
+    async def get_layers(self, file_id: str) -> List[LayerInfo]:
+        """获取图层"""
+        response = await self.send_request(CommandType.GET_LAYERS, {"file": file_id})
+        if response.status == ResponseStatus.FAIL:
+            raise Exception(response.error)
+        return [LayerInfo(**item, related=True) for item in response.payload]
+
+    async def delete_layer(self, file_id: str, layer_name: str) -> None:
+        """删除图层
+
+        Args:
+            file_id: 文件ID或文件名称
+            layer_name: 图层名称
+
+        Raises:
+            Exception: 删除失败时抛出异常
+        """
+        payload = {
+            "file": file_id,
+            "name": layer_name
+        }
+        response = await self.send_request(CommandType.DELETE_LAYER, payload)
+        if response.status == ResponseStatus.FAIL:
+            raise Exception(response.error)
+    
+    # 要素相关方法
+    async def create_feature(self, file_id: str, feature_name: str,
+                            feature_define: List[Dict[str, str]]) -> None:
+        """添加要素
+
+        Args:
+            file_id: 文件ID、文件名称
+            feature_name: 要素名称
+            feature_define: 属性定义列表, 每个元素包含:
+                - name: 属性名称
+                - type: 属性类型 ("string", "float", "int", "long", "short")
+
+        Raises:
+            Exception: 创建失败时抛出异常
+        """
+        payload = {
+            "file": file_id,
+            "feature_name": feature_name,
+            "feature_define": feature_define
+        }
+        response = await self.send_request(CommandType.CREATE_FEATURE, payload)
+        if response.status == ResponseStatus.FAIL:
+            raise Exception(response.error)
+
+
+    async def get_features(self, file_id: str) -> List[FeatureInfo]:
+        """获取要素
+
+        Args:
+            file_id: 文件ID
+
+        Returns:
+            要素信息列表
+
+        Raises:
+            Exception: 获取失败时抛出异常
+        """
+        response = await self.send_request(CommandType.GET_FEATURES, {"file": file_id})
+        if response.status == ResponseStatus.FAIL:
+            raise Exception(response.error)
+        return [FeatureInfo(**item, related=True) for item in response.payload]
+
+    async def update_feature(self, file_id: str, feature_name: str,
+                            feature_define: List[Dict[str, str]]) -> None:
+        """更新要素
+
+        Args:
+            file_id: 文件名称或文件ID
+            feature_name: 要素名称
+            feature_define: 属性定义列表, 每个元素包含:
+                - name: 属性名称
+                - type: 属性类型 ("string", "float", "int", "long", "short")
+
+        Raises:
+            Exception: 更新失败时抛出异常
+        """
+        payload = {
+            "file": file_id,
+            "feature_name": feature_name,
+            "feature_define": feature_define
+        }
+        response = await self.send_request(CommandType.UPDATE_FEATURE, payload)
+        if response.status == ResponseStatus.FAIL:
+            raise Exception(response.error)
+
+    async def delete_feature(self, file: str, feature_name: str) -> None:
+        """删除要素
+
+        Args:
+            file: 文件名称
+            feature_name: 要素名称
+
+        Raises:
+            Exception: 删除失败时抛出异常
+        """
+        payload = {
+            "file": file,
+            "feature_name": feature_name
+        }
+        response = await self.send_request(CommandType.DELETE_FEATURE, payload)
+        if response.status == ResponseStatus.FAIL:
+            raise Exception(response.error)
+
+    
+
+    async def get_selected(self)->List[GEOMETRY]:
+        """获取当前选中的模型"""
+        pass
+
+
+
+
+@asynccontextmanager
+async def open_client(url:Optional[str]=None)->AsyncGenerator[ConnClient,None]:
+    client = ConnClient(url=url or "ws://localhost:8000")
+    await client.connect()
+    yield client
+    await client.close()