PyGeoModel 1.0.8__tar.gz → 1.0.10__tar.gz

{pygeomodel-1.0.8 → pygeomodel-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyGeoModel
-Version: 1.0.8
+Version: 1.0.10
 Summary: A Python package for integrating OpenGMS geographic model services.
 Home-page: https://github.com/MpLebron/PyGeoModel
 Author: Peilong Ma

{pygeomodel-1.0.8 → pygeomodel-1.0.10}/PyGeoModel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyGeoModel
-Version: 1.0.8
+Version: 1.0.10
 Summary: A Python package for integrating OpenGMS geographic model services.
 Home-page: https://github.com/MpLebron/PyGeoModel
 Author: Peilong Ma

{pygeomodel-1.0.8 → pygeomodel-1.0.10}/pygeomodel/__init__.py

@@ -5,7 +5,7 @@ from .modeler import GeoModeler
 from .models import ModelInput, ModelOutput, ModelService, ModelSummary
 from .results import QAResult, RecommendationResult, TaskResult
 
-__version__ = "1.0.8"
+__version__ = "1.0.10"
 
 __all__ = [
     "GeoModeler",

{pygeomodel-1.0.8 → pygeomodel-1.0.10}/pygeomodel/modeler.py

@@ -90,6 +90,7 @@ class GeoModeler:
             outputs=response.get("outputs", []),
             execution_time=response.get("execution_time", time.time() - started),
             endpoint=getattr(self.client, "manager_url", None),
+            record_path=str(record_path) if record_path else None,
         )
         if output_dir:
             result.download(output_dir)

{pygeomodel-1.0.8 → pygeomodel-1.0.10}/pygeomodel/models.py

@@ -201,9 +201,15 @@ class ModelService:
             return str(value)
         dtype = (item.data_type or "").upper()
         if dtype in {"REAL", "DOUBLE", "FLOAT"}:
-            return float(value)
+            try:
+                return float(value)
+            except (TypeError, ValueError):
+                return value
         if dtype in {"INT", "INTEGER"}:
-            return int(value)
+            try:
+                return int(value)
+            except (TypeError, ValueError):
+                return value
         if dtype in {"BOOL", "BOOLEAN"}:
             if isinstance(value, str):
                 return value.strip().lower() in {"true", "1", "yes", "y"}

{pygeomodel-1.0.8 → pygeomodel-1.0.10}/pygeomodel/results.py

@@ -23,26 +23,47 @@ class TaskResult:
     model_name: str
     status: str = "unknown"
     outputs: list[dict[str, Any]] = field(default_factory=list)
+    downloaded_outputs: list[str] = field(default_factory=list)
     task_id: str | None = None
     model_id: str | None = None
     model_md5: str | None = None
     params: dict[str, Any] = field(default_factory=dict)
     uploaded_inputs: dict[str, Any] = field(default_factory=dict)
     endpoint: str | None = None
-    pygeomodel_version: str = "1.0.8"
+    pygeomodel_version: str = "1.0.10"
     execution_time: float | None = None
+    record_path: str | None = None
     created_at: float = field(default_factory=time.time)
 
     def to_dict(self) -> dict[str, Any]:
         return asdict(self)
 
     def to_json(self, path: str | Path) -> str:
+        self.record_path = str(path)
         return _write_json(self.to_dict(), path)
 
     def download(self, output_dir: str | Path) -> list[str]:
         from .client import download_output_files
 
-        return download_output_files(self.outputs, output_dir)
+        self.downloaded_outputs = download_output_files(self.outputs, output_dir)
+        return self.downloaded_outputs
+
+    def save(
+        self,
+        output_dir: str | Path | None = None,
+        record_path: str | Path | None = None,
+    ) -> list[str]:
+        if output_dir is not None:
+            self.download(output_dir)
+        if record_path is not None:
+            self.to_json(record_path)
+        return self.downloaded_outputs
+
+    def _repr_markdown_(self) -> str:
+        return f"Model run: {self.model_name}\n\nStatus: {self.status}\n\nTask ID: {self.task_id or 'Not returned'}"
+
+    def _repr_html_(self) -> str:
+        return _task_result_to_html(self)
 
 
 @dataclass
@@ -207,13 +228,287 @@ class QAResult:
         """
 
 
+def _task_result_to_html(result: TaskResult) -> str:
+    status = html.escape(str(result.status or "unknown"))
+    status_class = "success" if status.lower() == "completed" else "neutral"
+    task_id = html.escape(str(result.task_id or "Not returned"))
+    runtime = _format_seconds(result.execution_time)
+    record_path = html.escape(str(result.record_path or "Not saved"))
+    endpoint = html.escape(str(result.endpoint or "Not recorded"))
+    output_count = len(result.outputs or [])
+    downloaded_count = len(result.downloaded_outputs or [])
+    outputs_html = _task_outputs_to_html(result.outputs or [])
+    downloaded_html = _downloaded_outputs_to_html(result.downloaded_outputs or [])
+    params_json = html.escape(json.dumps(result.params or {}, ensure_ascii=False, indent=2), quote=False)
+    uploaded_json = html.escape(json.dumps(result.uploaded_inputs or {}, ensure_ascii=False, indent=2), quote=False)
+
+    return f"""
+    <style>
+    .pygeomodel-task-card {{
+        font-family: PingFang SC, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        color: #1e293b;
+        border: 1px solid #dbe3ef;
+        border-radius: 8px;
+        background: #ffffff;
+        overflow: hidden;
+        max-width: 100%;
+        box-shadow: 0 1px 2px rgba(15, 23, 42, 0.04);
+    }}
+    .pygeomodel-task-card * {{ box-sizing: border-box; }}
+    .pygeomodel-task-head {{
+        display: flex;
+        align-items: flex-start;
+        gap: 14px;
+        padding: 16px 18px;
+        border-bottom: 1px solid #e5edf6;
+        background: #fbfdff;
+    }}
+    .pygeomodel-task-status {{
+        flex: 0 0 auto;
+        min-width: 88px;
+        text-align: center;
+        border-radius: 999px;
+        padding: 4px 10px;
+        font-size: 12px;
+        line-height: 1.5;
+        font-weight: 750;
+        border: 1px solid #cbd5e1;
+        color: #475569;
+        background: #f8fafc;
+    }}
+    .pygeomodel-task-status.success {{
+        border-color: #bbf7d0;
+        color: #15803d;
+        background: #f0fdf4;
+    }}
+    .pygeomodel-task-title {{
+        min-width: 0;
+    }}
+    .pygeomodel-task-title h4 {{
+        margin: 0;
+        color: #0f172a;
+        font-size: 15px;
+        line-height: 1.4;
+        font-weight: 750;
+    }}
+    .pygeomodel-task-title p {{
+        margin: 4px 0 0 0;
+        color: #64748b;
+        font-size: 12px;
+        line-height: 1.5;
+    }}
+    .pygeomodel-task-body {{
+        padding: 14px 18px 16px 18px;
+    }}
+    .pygeomodel-task-meta {{
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(210px, 1fr));
+        gap: 10px;
+        margin-bottom: 16px;
+    }}
+    .pygeomodel-task-meta div {{
+        border-top: 1px solid #e5edf6;
+        padding-top: 8px;
+    }}
+    .pygeomodel-task-meta b {{
+        display: block;
+        color: #475569;
+        font-size: 11px;
+        line-height: 1.4;
+        font-weight: 750;
+        text-transform: uppercase;
+        letter-spacing: 0.02em;
+    }}
+    .pygeomodel-task-meta span {{
+        display: block;
+        margin-top: 3px;
+        color: #0f172a;
+        font-size: 12px;
+        line-height: 1.45;
+        overflow-wrap: anywhere;
+    }}
+    .pygeomodel-task-section {{
+        margin-top: 14px;
+    }}
+    .pygeomodel-task-section h4 {{
+        margin: 0 0 8px 0;
+        color: #0f172a;
+        font-size: 14px;
+        line-height: 1.4;
+        font-weight: 750;
+    }}
+    .pygeomodel-task-table {{
+        display: grid;
+        grid-template-columns: minmax(180px, 1.1fr) minmax(140px, 0.8fr) minmax(100px, 0.55fr) minmax(150px, 0.8fr);
+        border: 1px solid #dbe3ef;
+        border-radius: 8px;
+        overflow: hidden;
+        font-size: 12px;
+        line-height: 1.45;
+    }}
+    .pygeomodel-task-table > div {{
+        padding: 9px 11px;
+        border-bottom: 1px solid #e8eef6;
+        overflow-wrap: anywhere;
+    }}
+    .pygeomodel-task-table .head {{
+        background: #f8fafc;
+        color: #475569;
+        font-weight: 750;
+        text-transform: uppercase;
+        letter-spacing: 0.02em;
+        font-size: 11px;
+    }}
+    .pygeomodel-task-table .muted {{
+        color: #94a3b8;
+    }}
+    .pygeomodel-task-table a {{
+        color: #1d4ed8;
+        text-decoration: none;
+    }}
+    .pygeomodel-task-table a:hover {{ text-decoration: underline; }}
+    .pygeomodel-task-details {{
+        margin-top: 14px;
+        border-top: 1px solid #e5edf6;
+        padding-top: 10px;
+        color: #334155;
+        font-size: 12px;
+    }}
+    .pygeomodel-task-details summary {{
+        cursor: pointer;
+        font-weight: 700;
+    }}
+    .pygeomodel-task-details pre {{
+        margin: 10px 0 0 0;
+        padding: 10px;
+        border-radius: 6px;
+        background: #f8fafc;
+        border: 1px solid #e5edf6;
+        color: #0f172a;
+        font-size: 11px;
+        line-height: 1.45;
+        overflow-x: auto;
+        white-space: pre-wrap;
+    }}
+    @media (max-width: 840px) {{
+        .pygeomodel-task-head {{
+            display: block;
+        }}
+        .pygeomodel-task-status {{
+            display: inline-block;
+            margin-bottom: 10px;
+        }}
+        .pygeomodel-task-table {{
+            grid-template-columns: minmax(120px, 1fr) minmax(120px, 1fr);
+        }}
+    }}
+    </style>
+    <div class="pygeomodel-task-card">
+        <div class="pygeomodel-task-head">
+            <span class="pygeomodel-task-status {status_class}">{status}</span>
+            <div class="pygeomodel-task-title">
+                <h4>Model Execution Summary</h4>
+                <p>{html.escape(result.model_name)}</p>
+            </div>
+        </div>
+        <div class="pygeomodel-task-body">
+            <div class="pygeomodel-task-meta">
+                <div><b>Task ID</b><span>{task_id}</span></div>
+                <div><b>Runtime</b><span>{html.escape(runtime)}</span></div>
+                <div><b>Output resources</b><span>{output_count}</span></div>
+                <div><b>Saved output files</b><span>{downloaded_count}</span></div>
+                <div><b>Execution record</b><span>{record_path}</span></div>
+                <div><b>Endpoint</b><span>{endpoint}</span></div>
+                <div><b>PyGeoModel</b><span>{html.escape(str(result.pygeomodel_version))}</span></div>
+            </div>
+            <div class="pygeomodel-task-section">
+                <h4>Output resources</h4>
+                {outputs_html}
+            </div>
+            <div class="pygeomodel-task-section">
+                <h4>Saved output files</h4>
+                {downloaded_html}
+            </div>
+            <details class="pygeomodel-task-details">
+                <summary>Input parameters</summary>
+                <pre>{params_json}</pre>
+            </details>
+            <details class="pygeomodel-task-details">
+                <summary>Uploaded input structure</summary>
+                <pre>{uploaded_json}</pre>
+            </details>
+        </div>
+    </div>
+    """
+
+
+def _task_outputs_to_html(outputs: list[dict[str, Any]]) -> str:
+    if not outputs:
+        return '<div class="pygeomodel-task-table"><div class="muted">No output resources were returned.</div></div>'
+
+    rows = [
+        '<div class="head">Name</div>',
+        '<div class="head">State</div>',
+        '<div class="head">Format</div>',
+        '<div class="head">Access</div>',
+    ]
+    for output in outputs:
+        name = html.escape(str(output.get("tag") or output.get("event") or "Output"))
+        state = html.escape(str(output.get("statename") or ""))
+        suffix = html.escape(str(output.get("suffix") or "Not specified"))
+        url = str(output.get("url") or "")
+        if url:
+            safe_url = html.escape(url)
+            access = f'<a href="{safe_url}" target="_blank" rel="noopener noreferrer">Open output</a>'
+        else:
+            access = '<span class="muted">No downloadable URL returned</span>'
+        rows.extend([f"<div>{name}</div>", f"<div>{state}</div>", f"<div>{suffix}</div>", f"<div>{access}</div>"])
+    return f'<div class="pygeomodel-task-table">{"".join(rows)}</div>'
+
+
+def _downloaded_outputs_to_html(paths: list[str]) -> str:
+    if not paths:
+        return (
+            '<div class="pygeomodel-task-table">'
+            '<div class="muted">No output files were downloaded. This can happen when the OpenGMS service returns output metadata without a downloadable URL.</div>'
+            '</div>'
+        )
+
+    rows = [
+        '<div class="head">File</div>',
+        '<div class="head">Location</div>',
+        '<div class="head">Status</div>',
+        '<div class="head">Access</div>',
+    ]
+    for path in paths:
+        safe_path = html.escape(str(path))
+        name = html.escape(Path(path).name)
+        rows.extend([
+            f"<div>{name}</div>",
+            f"<div>{safe_path}</div>",
+            "<div>Saved</div>",
+            "<div>Local file</div>",
+        ])
+    return f'<div class="pygeomodel-task-table">{"".join(rows)}</div>'
+
+
+def _format_seconds(value: float | None) -> str:
+    if value is None:
+        return "Not recorded"
+    if value < 60:
+        return f"{value:.2f} s"
+    minutes = int(value // 60)
+    seconds = value - minutes * 60
+    return f"{minutes} min {seconds:.1f} s"
+
+
 def _recommendation_to_html(result: RecommendationResult) -> str:
     candidates = result.candidates or []
     recommended_data = result.recommended_data or {}
 
-    candidate_cards = "".join(_recommendation_candidate_card(candidate) for candidate in candidates)
-    if not candidate_cards:
-        candidate_cards = '<div class="pygeomodel-rec-empty">No candidate models were returned.</div>'
+    candidate_rows = "".join(_recommendation_candidate_row(candidate) for candidate in candidates)
+    if not candidate_rows:
+        candidate_rows = '<div class="pygeomodel-rec-empty">No candidate models were returned.</div>'
 
     local_data_html = _recommendation_data_items(recommended_data.get("local_data", []), label_key="location")
     kb_data_html = _recommendation_data_items(recommended_data.get("knowledge_base_data", []), label_key="url")
@@ -247,56 +542,66 @@ def _recommendation_to_html(result: RecommendationResult) -> str:
         line-height: 1.4;
         font-weight: 750;
     }}
-    .pygeomodel-rec-candidates {{
-        display: grid;
-        grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
-        gap: 10px;
-    }}
-    .pygeomodel-rec-candidate {{
+    .pygeomodel-rec-list {{
         border: 1px solid #dbe3ef;
         border-radius: 8px;
-        padding: 12px;
+        overflow: hidden;
         background: #ffffff;
     }}
-    .pygeomodel-rec-candidate.primary {{
-        border-color: #93c5fd;
+    .pygeomodel-rec-list-head,
+    .pygeomodel-rec-row {{
+        display: grid;
+        grid-template-columns: 90px minmax(220px, 0.95fr) minmax(280px, 1.25fr) minmax(220px, 1fr);
+        column-gap: 18px;
+        align-items: start;
+    }}
+    .pygeomodel-rec-list-head {{
+        padding: 9px 14px;
+        background: #f8fafc;
+        border-bottom: 1px solid #dbe3ef;
+        color: #475569;
+        font-size: 11px;
+        font-weight: 750;
+        letter-spacing: 0.02em;
+        text-transform: uppercase;
+    }}
+    .pygeomodel-rec-row {{
+        padding: 13px 14px;
+        border-bottom: 1px solid #e8eef6;
+    }}
+    .pygeomodel-rec-row:last-child {{
+        border-bottom: 0;
+    }}
+    .pygeomodel-rec-row.primary {{
         background: #f8fbff;
+        box-shadow: inset 3px 0 0 #60a5fa;
     }}
-    .pygeomodel-rec-candidate-top {{
-        display: flex;
-        gap: 8px;
-        align-items: flex-start;
-        justify-content: space-between;
-        margin-bottom: 7px;
+    .pygeomodel-rec-rank {{
+        color: #64748b;
+        font-size: 12px;
+        font-weight: 750;
+        line-height: 1.4;
+        white-space: nowrap;
     }}
-    .pygeomodel-rec-candidate-name {{
+    .pygeomodel-rec-name {{
         color: #0f172a;
         font-size: 13px;
         line-height: 1.35;
         font-weight: 750;
     }}
-    .pygeomodel-rec-badge {{
-        flex: 0 0 auto;
-        border-radius: 999px;
-        border: 1px solid #bfdbfe;
-        background: #dbeafe;
-        color: #1d4ed8;
-        padding: 2px 7px;
-        font-size: 11px;
-        font-weight: 700;
-        line-height: 1.4;
-    }}
-    .pygeomodel-rec-rank {{
-        color: #64748b;
-        font-size: 11px;
-        font-weight: 700;
-    }}
-    .pygeomodel-rec-candidate p {{
-        margin: 6px 0 0 0;
+    .pygeomodel-rec-description,
+    .pygeomodel-rec-text {{
+        margin: 0;
         color: #475569;
         font-size: 12px;
         line-height: 1.5;
     }}
+    .pygeomodel-rec-description {{
+        margin-top: 5px;
+    }}
+    .pygeomodel-rec-muted {{
+        color: #94a3b8;
+    }}
     .pygeomodel-rec-data-grid {{
         display: grid;
         grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
@@ -332,11 +637,32 @@ def _recommendation_to_html(result: RecommendationResult) -> str:
         padding: 12px;
         background: #f8fafc;
     }}
+    @media (max-width: 900px) {{
+        .pygeomodel-rec-list-head {{
+            display: none;
+        }}
+        .pygeomodel-rec-row {{
+            grid-template-columns: 76px minmax(0, 1fr);
+            row-gap: 8px;
+        }}
+        .pygeomodel-rec-row > div:nth-child(3),
+        .pygeomodel-rec-row > div:nth-child(4) {{
+            grid-column: 2;
+        }}
+    }}
     </style>
     <div class="pygeomodel-rec-card">
         <div class="pygeomodel-rec-body">
             <div class="pygeomodel-rec-section">
-                <div class="pygeomodel-rec-candidates">{candidate_cards}</div>
+                <div class="pygeomodel-rec-list">
+                    <div class="pygeomodel-rec-list-head">
+                        <div>Rank</div>
+                        <div>Candidate model</div>
+                        <div>Recommendation rationale</div>
+                        <div>Input data</div>
+                    </div>
+                    {candidate_rows}
+                </div>
             </div>
             <div class="pygeomodel-rec-section">
                 <h4>Relevant Data</h4>
@@ -356,7 +682,7 @@ def _recommendation_to_html(result: RecommendationResult) -> str:
     """
 
 
-def _recommendation_candidate_card(candidate: dict[str, Any]) -> str:
+def _recommendation_candidate_row(candidate: dict[str, Any]) -> str:
     name = html.escape(str(candidate.get("name") or "Unnamed model"))
     description = html.escape(str(candidate.get("description") or candidate.get("desc") or ""))
     reason = html.escape(str(candidate.get("reason") or candidate.get("recommendation_reason") or ""))
@@ -364,20 +690,19 @@ def _recommendation_candidate_card(candidate: dict[str, Any]) -> str:
     rank = html.escape(str(candidate.get("rank") or ""))
     is_primary = bool(candidate.get("is_primary"))
     primary_class = " primary" if is_primary else ""
-    badge = '<span class="pygeomodel-rec-badge">Recommended</span>' if is_primary else ""
+    rank_label = f"&#9733; Rank {rank}" if is_primary else f"Rank {rank}"
 
     return f"""
-    <div class="pygeomodel-rec-candidate{primary_class}">
-        <div class="pygeomodel-rec-candidate-top">
-            <div>
-                <div class="pygeomodel-rec-rank">Rank {rank}</div>
-                <div class="pygeomodel-rec-candidate-name">{name}</div>
-            </div>
-            {badge}
+    <div class="pygeomodel-rec-row{primary_class}">
+        <div class="pygeomodel-rec-rank">
+            {rank_label}
+        </div>
+        <div>
+            <div class="pygeomodel-rec-name">{name}</div>
+            {f'<p class="pygeomodel-rec-description">{description}</p>' if description else ''}
         </div>
-        {f'<p>{description}</p>' if description else ''}
-        {f'<p><b>Why:</b> {reason}</p>' if reason else ''}
-        {f'<p><b>Input data:</b> {input_desc}</p>' if input_desc else ''}
+        <p class="pygeomodel-rec-text">{reason if reason else '<span class="pygeomodel-rec-muted">No recommendation rationale recorded.</span>'}</p>
+        <p class="pygeomodel-rec-text">{input_desc if input_desc else '<span class="pygeomodel-rec-muted">No input-data description recorded.</span>'}</p>
     </div>
     """
 

{pygeomodel-1.0.8 → pygeomodel-1.0.10}/setup.py

@@ -11,7 +11,7 @@ def read_readme():
 
 setup(
     name="PyGeoModel",
-    version="1.0.8",
+    version="1.0.10",
     author="Peilong Ma",
     author_email="mpl_gis@nnu.edu.cn",
     description="A Python package for integrating OpenGMS geographic model services.",

{pygeomodel-1.0.8 → pygeomodel-1.0.10}/tests/test_core_api.py

@@ -97,6 +97,36 @@ class CoreApiTests(unittest.TestCase):
         self.assertEqual(normalized["SpatialAnalysis"]["end_time"], 201812)
         self.assertTrue(normalized["SolarCalculation"]["roof_vector_path"].endswith("rooftops.zip"))
 
+    def test_model_invocation_records_downloaded_output_paths(self):
+        import pygeomodel.client as client_module
+        from pygeomodel import GeoModeler
+
+        original_downloader = client_module.download_output_files
+        try:
+            client_module.download_output_files = lambda outputs, output_dir: [
+                str(Path(output_dir) / "SolarCalculation-roofSloar.zip")
+            ]
+
+            with tempfile.TemporaryDirectory() as tmpdir:
+                modeler = GeoModeler(client=FakeClient())
+                result = modeler.invoke(
+                    "Roof Photovoltaic Carbon Emission Reduction Potential Assessment Model",
+                    params={
+                        "system_efficiency": 0.8,
+                        "start_time": 201801,
+                        "end_time": 201812,
+                        "roof_vector_path": str(Path(tmpdir) / "rooftops.zip"),
+                    },
+                    output_dir=Path(tmpdir) / "outputs",
+                )
+        finally:
+            client_module.download_output_files = original_downloader
+
+        self.assertEqual(
+            result.downloaded_outputs,
+            [str(Path(tmpdir) / "outputs" / "SolarCalculation-roofSloar.zip")],
+        )
+
     def test_model_invocation_preserves_multi_child_internal_params(self):
         from pygeomodel import GeoModeler
 
@@ -298,6 +328,113 @@ class CoreApiTests(unittest.TestCase):
             qa_path = qa.to_json(tmpdir / "qa.json")
             self.assertEqual(json.loads(Path(qa_path).read_text())["answer"], "a")
 
+    def test_task_result_save_records_metadata_and_outputs(self):
+        import pygeomodel.client as client_module
+        from pygeomodel import TaskResult
+
+        original_downloader = client_module.download_output_files
+        try:
+            client_module.download_output_files = lambda outputs, output_dir: [
+                str(Path(output_dir) / "SolarCalculation-roofSloar.zip")
+            ]
+
+            with tempfile.TemporaryDirectory() as tmpdir:
+                tmpdir = Path(tmpdir)
+                result = TaskResult(
+                    model_name="m",
+                    status="completed",
+                    task_id="task-123",
+                    outputs=[{"url": "http://example.test/result.zip", "tag": "roofSloar", "suffix": "zip"}],
+                    params={"system_efficiency": 0.8},
+                )
+
+                returned = result.save(
+                    output_dir=tmpdir / "outputs",
+                    record_path=tmpdir / "records" / "execution_record.json",
+                )
+                record = json.loads((tmpdir / "records" / "execution_record.json").read_text())
+        finally:
+            client_module.download_output_files = original_downloader
+
+        self.assertEqual(returned, [str(tmpdir / "outputs" / "SolarCalculation-roofSloar.zip")])
+        self.assertEqual(
+            result.downloaded_outputs,
+            [str(tmpdir / "outputs" / "SolarCalculation-roofSloar.zip")],
+        )
+        self.assertEqual(record["task_id"], "task-123")
+        self.assertEqual(record["record_path"], str(tmpdir / "records" / "execution_record.json"))
+        self.assertEqual(record["downloaded_outputs"], result.downloaded_outputs)
+
+    def test_task_result_save_only_outputs_when_no_record_path_is_given(self):
+        import pygeomodel.client as client_module
+        from pygeomodel import TaskResult
+
+        original_downloader = client_module.download_output_files
+        try:
+            client_module.download_output_files = lambda outputs, output_dir: [
+                str(Path(output_dir) / "SolarCalculation-roofSloar.zip")
+            ]
+
+            with tempfile.TemporaryDirectory() as tmpdir:
+                tmpdir = Path(tmpdir)
+                result = TaskResult(
+                    model_name="m",
+                    status="completed",
+                    task_id="task-123",
+                    outputs=[{"url": "http://example.test/result.zip", "tag": "roofSloar", "suffix": "zip"}],
+                )
+
+                returned = result.save(output_dir=tmpdir / "outputs")
+                implicit_record = tmpdir / "outputs" / "execution_record.json"
+        finally:
+            client_module.download_output_files = original_downloader
+
+        self.assertEqual(returned, [str(tmpdir / "outputs" / "SolarCalculation-roofSloar.zip")])
+        self.assertEqual(
+            result.downloaded_outputs,
+            [str(tmpdir / "outputs" / "SolarCalculation-roofSloar.zip")],
+        )
+        self.assertIsNone(result.record_path)
+        self.assertFalse(implicit_record.exists())
+
+    def test_task_result_has_notebook_rich_display(self):
+        from pygeomodel import TaskResult
+
+        result = TaskResult(
+            model_name="Roof Photovoltaic Carbon Emission Reduction Potential Assessment Model",
+            status="completed",
+            task_id="task-123",
+            outputs=[
+                {
+                    "statename": "SolarCalculation",
+                    "event": "roofSloar",
+                    "tag": "SolarCalculation-roofSloar",
+                    "suffix": "",
+                    "url": "",
+                }
+            ],
+            params={
+                "system_efficiency": 0.8,
+                "start_time": 201801,
+                "end_time": 201812,
+                "roof_vector_path": "data/xuanwu_rooftop.zip",
+            },
+            record_path="records/execution_record.json",
+            execution_time=103.39,
+        )
+
+        html = result._repr_html_()
+
+        self.assertIn("Model Execution Summary", html)
+        self.assertIn("completed", html)
+        self.assertIn("task-123", html)
+        self.assertIn("records/execution_record.json", html)
+        self.assertIn("Input parameters", html)
+        self.assertIn("roof_vector_path", html)
+        self.assertIn("Output resources", html)
+        self.assertIn("No downloadable URL returned", html)
+        self.assertNotIn("TaskResult(", html)
+
     def test_opengms_config_uses_public_demo_token_as_fallback(self):
         import pygeomodel.config as config_module
 
@@ -403,7 +540,8 @@ class CoreApiTests(unittest.TestCase):
 
         html = result._repr_html_()
 
-        self.assertIn("Recommended", html)
+        self.assertIn("★ Rank 1", html)
+        self.assertNotIn("Recommended</span>", html)
         self.assertIn("Solar Potential Analysis Model", html)
         self.assertIn("Rooftop Suitability Model", html)
         self.assertIn("Relevant Data", html)