PyGeoModel 1.0.0__py3-none-any.whl

ogmsServer2/openUtils/http_client.py

@@ -0,0 +1,247 @@
+import httpx
+from typing import Optional, Dict, Any, Union, Tuple
+import asyncio
+
+# 类型别名
+Headers = Dict[str, str]
+Files = Dict[str, Tuple[str, Any]]
+
+
+class HttpClient:
+    @staticmethod
+    def _make_sync_request(
+        method: str,
+        url: str,
+        timeout: int = 10,
+        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        files: Optional[Files] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Headers] = None,
+        downloadFile: bool = False,
+    ) -> Dict[str, Any]:
+        try:
+            with httpx.Client(timeout=httpx.Timeout(timeout)) as client:
+                response = client.request(
+                    method,
+                    url,
+                    data=data,
+                    json=json,
+                    files=files,
+                    params=params,
+                    headers=headers,
+                )
+                print
+                response.raise_for_status()  # 检查 HTTP 错误
+                if downloadFile:
+                    return {
+                        "status_code": response.status_code,
+                        "headers": dict(response.headers),
+                        "content": response.content,
+                    }
+                return {
+                    "status_code": response.status_code,
+                    "headers": dict(response.headers),
+                    "json": response.json(),
+                }
+        except httpx.TimeoutException:
+            # 处理超时错误
+            return {"status_code": None, "headers": None, "error": "Request timed out"}
+        except httpx.HTTPStatusError as e:
+            return {
+                "status_code": e.response.status_code,
+                "headers": dict(e.response.headers),
+                "error": str(e),
+            }
+        except httpx.RequestError as e:
+            return {
+                "status_code": None,
+                "headers": None,
+                "error": f"Request error: {e}",
+            }
+        except Exception as e:
+            return {
+                "status_code": None,
+                "headers": None,
+                "error": f"Unexpected error: {e}",
+            }
+
+    @staticmethod
+    def hander_response(response):
+        if response["status_code"] == 200:
+            return response
+        else:
+            raise Exception(response["error"])
+
+    @staticmethod
+    def get_sync(
+        url: str,
+        timeout: int = 10,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Headers] = None,
+    ) -> Dict[str, Any]:
+        return HttpClient._make_sync_request(
+            "GET", url, timeout=timeout, params=params, headers=headers
+        )
+
+    @staticmethod
+    def get_file_sync(
+        url: str,
+        timeout: int = 10,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Headers] = None,
+    ):
+        response = HttpClient._make_sync_request(
+            "GET",
+            url,
+            timeout=timeout,
+            params=params,
+            headers=headers,
+            downloadFile=True,
+        )
+        return response
+
+    @staticmethod
+    def post_sync(
+        url: str,
+        timeout: int = 10,
+        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        files: Optional[Files] = None,
+        headers: Optional[Headers] = None,
+    ) -> Dict[str, Any]:
+        return HttpClient._make_sync_request(
+            "POST",
+            url,
+            timeout=timeout,
+            data=data,
+            json=json,
+            files=files,
+            headers=headers,
+        )
+
+    @staticmethod
+    def put_sync(
+        url: str,
+        timeout: int = 10,
+        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        headers: Optional[Headers] = None,
+    ) -> Dict[str, Any]:
+        return HttpClient._make_sync_request(
+            "PUT", url, timeout=timeout, data=data, json=json, headers=headers
+        )
+
+    @staticmethod
+    def delete_sync(
+        url: str,
+        timeout: int = 10,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Headers] = None,
+    ) -> Dict[str, Any]:
+        return HttpClient._make_sync_request(
+            "DELETE", url, timeout=timeout, params=params, headers=headers
+        )
+
+    @staticmethod
+    async def _make_async_request(
+        method: str,
+        url: str,
+        timeout: int = 10,
+        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        files: Optional[Files] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Headers] = None,
+    ) -> Dict[str, Any]:
+        try:
+            async with httpx.AsyncClient(timeout=httpx.Timeout(timeout)) as client:
+                response = await client.request(
+                    method,
+                    url,
+                    data=data,
+                    json=json,
+                    files=files,
+                    params=params,
+                    headers=headers,
+                )
+                response.raise_for_status()  # 检查 HTTP 错误
+                return {
+                    "status_code": response.status_code,
+                    "headers": dict(response.headers),
+                    "json": response.json(),
+                }
+        except httpx.TimeoutException:
+            # 处理超时错误
+            return {"status_code": None, "headers": None, "error": "Request timed out"}
+        except httpx.HTTPStatusError as e:
+            return {
+                "status_code": e.response.status_code,
+                "headers": dict(e.response.headers),
+                "error": str(e),
+            }
+        except httpx.RequestError as e:
+            return {
+                "status_code": None,
+                "headers": None,
+                "error": f"Request error: {e}",
+            }
+        except Exception as e:
+            return {
+                "status_code": None,
+                "headers": None,
+                "error": f"Unexpected error: {e}",
+            }
+
+    @staticmethod
+    async def get_async(
+        url: str,
+        timeout: int = 10,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Headers] = None,
+    ) -> Dict[str, Any]:
+        return await HttpClient._make_async_request(
+            "GET", url, timeout=timeout, params=params, headers=headers
+        )
+
+    @staticmethod
+    async def post_async(
+        url: str,
+        timeout: int = 10,
+        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        files: Optional[Files] = None,
+        headers: Optional[Headers] = None,
+    ) -> Dict[str, Any]:
+        return await HttpClient._make_async_request(
+            "POST",
+            url,
+            timeout=timeout,
+            data=data,
+            json=json,
+            files=files,
+            headers=headers,
+        )
+
+    @staticmethod
+    async def put_async(
+        url: str,
+        timeout: int = 10,
+        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        headers: Optional[Headers] = None,
+    ) -> Dict[str, Any]:
+        return await HttpClient._make_async_request(
+            "PUT", url, timeout=timeout, data=data, json=json, headers=headers
+        )
+
+    @staticmethod
+    async def delete_async(
+        url: str,
+        timeout: int = 10,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Headers] = None,
+    ) -> Dict[str, Any]:
+        return await HttpClient._make_async_request(
+            "DELETE", url, timeout=timeout, params=params, headers=headers
+        )

ogmsServer2/openUtils/mdlUtils.py

@@ -0,0 +1,116 @@
+"""
+Author: DiChen
+Date: 2024-09-09 21:19:00
+LastEditors: DiChen
+LastEditTime: 2024-09-09 21:25:48
+"""
+
+
+class MDL:
+    # TODO:应该为动态IP
+    def __init__(self):
+        self.ip = "172.21.252.204"
+        self.port = 8061
+        self.origin_lists = {}
+
+    def resolvingMDL(self, mdlData: dict):
+        if mdlData:
+            self.origin_lists = self.parse_model_data(mdlData)
+            return self.origin_lists
+        else:
+            # TODO: 处理无mdl的情况
+            return None
+
+    ####################### private#######################
+
+    def parse_model_data(self, mdl_data: dict):
+        def extract_children(udx_node):
+            return [
+                {
+                    "eventId": child["name"],
+                    "eventName": child["name"],
+                    "eventDesc": child["name"],
+                    "eventType": child["type"]
+                    .replace("DTKT_", "")
+                    .replace("REAL", "FLOAT"),
+                    "child": "true",
+                    "value": "",
+                }
+                for child in udx_node.get("UdxNode", [])
+            ]
+
+        def process_event(event, evt, dataset_item, data, is_input=True):
+            entry_type = "inputs" if is_input else "outputs"
+            entry = {
+                "statename": event.get("name"),
+                "event": evt.get("name"),
+                "optional": evt.get("optional"),
+            }
+            if is_input:
+                entry.update(
+                    {
+                        "url": "",
+                        "tag": dataset_item.get("name"),
+                        "suffix": "",
+                    }
+                )
+            else:
+                entry["template"] = {
+                    "type": "id" if "externalId" in dataset_item else "None",
+                    "value": dataset_item.get("externalId", ""),
+                }
+
+            if dataset_item["type"] == "internal" and dataset_item.get(
+                    "UdxDeclaration"
+            ):
+                udx_node = dataset_item["UdxDeclaration"][0].get("UdxNode")
+                if udx_node:
+                    entry["children"] = extract_children(
+                        dataset_item["UdxDeclaration"][0]["UdxNode"][0]
+                    )
+
+            data[entry_type].append(entry)
+
+        data = {
+            "outputs": [],
+            "port": self.port,  # Fill with actual port if available
+            "inputs": [],
+            "ip": self.ip,  # Fill with actual IP if available
+            "pid": mdl_data.get("md5", ""),
+            "oid": mdl_data.get("id", ""),
+            "username": "",  # Fill with actual username if available
+        }
+        related_datasets = mdl_data["mdlJson"]["ModelClass"][0]["Behavior"][0][
+            "RelatedDatasets"
+        ][0]["DatasetItem"]
+
+        for model_class in mdl_data.get("mdlJson", {}).get("ModelClass", []):
+            for behavior in model_class.get("Behavior", []):
+                for state_group in behavior.get("StateGroup", []):
+                    for state in state_group.get("States", []):
+                        for event in state.get("State", []):
+                            for evt in event.get("Event", []):
+                                dataset_reference = evt.get(
+                                    "ResponseParameter",
+                                    evt.get("DispatchParameter", []),
+                                )
+                                for param in dataset_reference:
+                                    dataset_item = next(
+                                        (
+                                            item
+                                            for item in related_datasets
+                                            if item["name"] == param["datasetReference"]
+                                        ),
+                                        None,
+                                    )
+                                    if dataset_item:
+                                        process_event(
+                                            event,
+                                            evt,
+                                            dataset_item,
+                                            data,
+                                            is_input=(evt.get("type")
+                                                      == "response"),
+                                        )
+
+        return data

ogmsServer2/openUtils/parameterValidator.py

@@ -0,0 +1,55 @@
+"""
+Author: DiChen
+Date: 2024-09-07 00:58:14
+LastEditors: DiChen
+LastEditTime: 2024-09-09 19:06:45
+"""
+
+from .exceptions import NotValueError, modelStatusError
+
+STATUS = ["Model sign"]
+
+
+class ParameterValidator:
+    @staticmethod
+    def v_str(param):
+        if not isinstance(param, str):
+            raise ValueError("Parameter must be a string.")
+
+    @staticmethod
+    def v_int(param):
+        if not isinstance(param, int):
+            raise ValueError("Parameter must be an integer.")
+
+    @staticmethod
+    def v_float(param):
+        if not isinstance(param, float):
+            raise ValueError("Parameter must be a float.")
+
+    @staticmethod
+    def v_list(param):
+        if not isinstance(param, list):
+            raise ValueError("Parameter must be a list.")
+
+    @staticmethod
+    def v_dict(param):
+        if not isinstance(param, dict):
+            raise ValueError("Parameter must be a dictionary.")
+
+    @staticmethod
+    def v_empty(param, name: str):
+        if (
+            param is None
+            or param == {}
+            or param == []
+            or (param is str and not param.strip())
+        ):
+            if name in STATUS:
+                raise NotValueError(f"{name} occurs error, please try again!")
+            raise NotValueError(f"{name} cannot be empty,plesae check!")
+
+    @staticmethod
+    def v_status(param):
+        if param == -1 or param == -2:
+            raise modelStatusError(f"model service calculate error!")
+        return param

ogmsServer2/openUtils/stateManager.py

@@ -0,0 +1,69 @@
+"""
+Author: DiChen
+Date: 2024-09-06 17:21:20
+LastEditors: DiChen
+LastEditTime: 2024-09-13 21:54:57
+"""
+
+"""
+Author: DiChen
+Date: 2024-09-06 17:21:20
+LastEditors: DiChen
+LastEditTime: 2024-09-08 16:23:59
+"""
+
+# 定义状态常量
+STATE_INIT = 0b1  # 1: init
+STATE_RUNNING = 0b10  # 2: running
+STATE_COMPLETED = 0b100  # 4: completed
+STATE_ERROR = 0b1000  # 8: error
+
+
+class StateManager:
+    def __init__(self):
+        # init state
+        self.state = STATE_INIT
+        print(f"StateManager initialized in state: {bin(self.state)}")
+
+    def addState(self, state):
+        """add state"""
+        self.state |= state
+
+    def removeState(self, state):
+        """remove state"""
+        self.state &= ~state
+
+    def hasStatus(self, state):
+        """check state"""
+        return self.state & state != 0
+
+    def trans2Status(self, state):
+        """transition to state"""
+        if state == STATE_RUNNING and not self.hasStatus(STATE_INIT):
+            print("Cannot run without initialization")
+            return
+
+        if state == STATE_COMPLETED and not self.hasStatus(STATE_RUNNING):
+            print("Cannot complete without running")
+            return
+
+        if state == STATE_ERROR:
+            print("Error occurred, transitioning to ERROR state")
+            self.state = state
+            return
+
+        self.state = state
+        print(f"Transitioned to state: {bin(self.state)}")
+
+    def getState(self):
+        """get state"""
+        return bin(self.state)
+
+    def checkInputStatus(self, status):
+        """check input status"""
+        if status == 1 and self.state == STATE_INIT:
+            self.addState(STATE_RUNNING)
+            print("model service calculating!")
+        elif status == 2:
+            self.addState(STATE_COMPLETED)
+            print("model calculation was completed!")

pygeomodel-1.0.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: PyGeoModel
+Version: 1.0.0
+Summary: An intelligent Python toolkit for geographic modeling with smart model recommendations
+Home-page: https://github.com/yourusername/PyGeoModel
+Author: Your Name
+Author-email: your.email@example.com
+Keywords: geographic modeling,GIS,machine learning,model recommendation,geospatial analysis,jupyter
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ipywidgets>=7.6.0
+Requires-Dist: requests>=2.25.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: ipyfilechooser>=0.6.0
+Requires-Dist: markdown>=3.3.0
+Requires-Dist: nest-asyncio>=1.5.0
+Requires-Dist: geopandas>=0.10.0
+Requires-Dist: rasterio>=1.2.0
+Requires-Dist: nbformat>=5.1.0
+Requires-Dist: tenacity>=8.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Model GUI Tool
+
+This is a GUI tool for displaying and running computational models, implemented using ipywidgets in Jupyter notebook.
+
+## Features
+
+- Load model definitions from JSON configuration files
+- Provide graphical interface for model selection, parameter configuration and execution
+- Display model basic information (name, description, author, tags etc.)
+- Support file chooser for model parameter inputs 
+- Provide output area for execution results
+- Support multiple model management
+- Real-time model status monitoring
+- Parameter validation and error handling
+- Support model state transitions
+- Export model results to various formats
+- Model comparison and analysis tools
+- Batch processing capabilities
+- Customizable model visualization
+- Integration with external tools and libraries
+- Comprehensive logging and debugging features
+
+## Usage
+
+1. Ensure required dependencies are installed:

pygeomodel-1.0.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+pygeomodel.py,sha256=3wrUEK4pMlgNyS2t5ryrqNfDA7ldByWEVcUaJebS_kw,103905
+scripts.py,sha256=MMjwutjzMCJSjBcs84zV6gBqAMHH8vBi3a-qM2g2iDQ,5862
+ogmsServer2/__init__.py,sha256=-bD8jrIG4mdQs-Oj7bVVC_tw8266IuY-EmphwMrCx0w,587
+ogmsServer2/base.py,sha256=hKNPHJOERiP05iDrimZDrsCILs-r3GHPmYJ7HLPW0bQ,1160
+ogmsServer2/constants.py,sha256=smDuFk2Xp2T_se0ChGUBLJnSUJNSGRMkU6WDAK0Q3Jg,682
+ogmsServer2/openModel.py,sha256=o5d-ePjQh-0-dzkJxgx1yAdPuDMG6gwty5w49K9f61k,15350
+ogmsServer2/data/PGA.tif,sha256=Yb43WS84mLX0ZYlarjeH3QLyJcSrEu09SH5kXBQvdgc,66368
+ogmsServer2/data/baseclip.tif,sha256=ZLbfJqJ3H62G0_1an-HubttEwLSNbn8WzHIj8agdTg0,263005
+ogmsServer2/data/intensity.tif,sha256=rjpbOA-flY_Xe3sSOlxhg-U4lH4g0vMQSwBXGOGQOso,33600
+ogmsServer2/data/地震群发滑坡概率评估预警模型_67c32dc057e89375/LandSlide-outputIntensitypbtyTif.tif,sha256=b7gwhktEQUmJfBzUjmDxRUnmUSfxvAQTIt0ByxzTWBk,162288
+ogmsServer2/data/地震群发滑坡概率评估预警模型_67c32dc057e89375/LandSlide-outputPGApbtyTif.tif,sha256=gxQtO_3pB6w8LyfhRyqLfVt9oI1P14nbLXSZma0yw-U,162288
+ogmsServer2/data/地震群发滑坡概率评估预警模型_7972c0716caa1213/LandSlide-outputIntensitypbtyTif.tif,sha256=b7gwhktEQUmJfBzUjmDxRUnmUSfxvAQTIt0ByxzTWBk,162288
+ogmsServer2/data/地震群发滑坡概率评估预警模型_7972c0716caa1213/LandSlide-outputPGApbtyTif.tif,sha256=gxQtO_3pB6w8LyfhRyqLfVt9oI1P14nbLXSZma0yw-U,162288
+ogmsServer2/data/地震群发滑坡概率评估预警模型_a044c410df669372/LandSlide-outputIntensitypbtyTif.tif,sha256=b7gwhktEQUmJfBzUjmDxRUnmUSfxvAQTIt0ByxzTWBk,162288
+ogmsServer2/data/地震群发滑坡概率评估预警模型_a044c410df669372/LandSlide-outputPGApbtyTif.tif,sha256=gxQtO_3pB6w8LyfhRyqLfVt9oI1P14nbLXSZma0yw-U,162288
+ogmsServer2/data/地震群发滑坡概率评估预警模型_b6ba56c07bf80c30/LandSlide-outputIntensitypbtyTif.tif,sha256=b7gwhktEQUmJfBzUjmDxRUnmUSfxvAQTIt0ByxzTWBk,162288
+ogmsServer2/data/地震群发滑坡概率评估预警模型_b6ba56c07bf80c30/LandSlide-outputPGApbtyTif.tif,sha256=gxQtO_3pB6w8LyfhRyqLfVt9oI1P14nbLXSZma0yw-U,162288
+ogmsServer2/openUtils/__init__.py,sha256=aDdiNILgqP3y7MWc52pWb06kvFdpFtxrFB0LN2U40rE,480
+ogmsServer2/openUtils/exceptions.py,sha256=lJcX5-BFk-a71ZCSFLVnDj6jYjHRfl6pTAq_9pJABSg,1920
+ogmsServer2/openUtils/http_client.py,sha256=ysL9yAUtvZqUb1CreuM0tu-DcTbloQYn9eLfryGAUBo,7893
+ogmsServer2/openUtils/mdlUtils.py,sha256=gen4oPm4tu9_nMVObd8WPXtLnFqDSSXKhiTLr0cx-nA,4475
+ogmsServer2/openUtils/parameterValidator.py,sha256=aJ1jErdnpCYQl_qesLbIX2TqHe686AMcZ3OZRQZNKcI,1490
+ogmsServer2/openUtils/stateManager.py,sha256=i-o-I3jif65S5ExGZRS1qRD3a80Gb0JI_T8-lOvyz9o,1826
+pygeomodel-1.0.0.dist-info/licenses/LICENSE,sha256=d0s_lsrYXV0oUUz3EkBpLyFMjg4kQzOnm2wxgA1wu5g,1067
+pygeomodel-1.0.0.dist-info/METADATA,sha256=60iZNI8rHiMLLXQqC3rHEwRZwha4kUGWF5h0fLg8Sfw,2430
+pygeomodel-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pygeomodel-1.0.0.dist-info/top_level.txt,sha256=FZA4z-JV_S6Z1vMeG01FRhWHq5C-ckm8ZrZwymhHIEM,31
+pygeomodel-1.0.0.dist-info/RECORD,,

pygeomodel-1.0.0.dist-info/WHEEL

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

pygeomodel-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 PyGeoModel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pygeomodel-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+ogmsServer2
+pygeomodel
+scripts