Add KML terrain and soil analysis layers

README.md

@@ -14,7 +14,7 @@ pinned: false
 
 Preliminary architecture site-analysis assistant for the Build Small Hackathon.
 
-Draw, pin, or upload a site boundary to generate a first-pass site-analysis board pack with climate context, OSM surroundings, sun/wind notes, evidence labels, and a site-visit checklist. The main output is a downloadable presentation-board PNG/PDF plus an editable Markdown report.
+Draw, pin, or upload a site boundary to generate a first-pass site-analysis board pack with climate context, OSM surroundings, terrain and preliminary soil signals, sun/wind notes, evidence labels, and a site-visit checklist. The main output is a downloadable presentation-board PNG/PDF plus an editable Markdown report.
 
 This is not a legal boundary verifier, geotechnical survey, structural engineering tool, final foundation recommender, or building design generator. Public data may be coarse or incomplete. Verify findings on site and with qualified professionals.
 
@@ -28,10 +28,13 @@ Architecture students and early-career architects often begin studio projects by
 - Paste latitude/longitude or a Google Maps URL that contains coordinates.
 - Reverse-geocode the selected anchor/centroid into approximate address, city/state, and country context when available.
 - Upload DXF and choose detected boundary candidates.
+- Upload Google Earth/GIS-style KML/KMZ boundaries.
 - Upload GeoJSON boundaries.
 - Generate a sheet-style presentation board preview with downloadable PNG and PDF.
 - Generate climate, sun/wind, context, evidence, checklist, and Markdown report export.
 - Label climate data as forecast/current, recent historical, or climate-normal style.
+- Add OpenTopoData SRTM elevation sampling for early slope/drainage awareness.
+- Add SoilGrids preliminary topsoil texture signals with professional-verification warnings.
 - Keep all unsafe soil, legal-boundary, and foundation claims out of the report.
 
 ## Data Sources
@@ -40,13 +43,15 @@ Architecture students and early-career architects often begin studio projects by
 - Open-Meteo Historical Weather API for recent historical and climate-normal style summaries.
 - OpenStreetMap and Overpass API for mapped context features.
 - OpenStreetMap Nominatim for one generate-time reverse geocoding lookup from the site anchor/centroid.
+- OpenTopoData SRTM 90m elevation API for preliminary sampled elevation/relief.
+- SoilGrids / ISRIC global soil model for preliminary topsoil texture indicators.
 - Leaflet for the local interactive map UI, vendored in `assets/` to avoid CDN startup failures.
-- Local geometry calculations for drawn, pin-radius, GeoJSON, and DXF-derived boundaries.
+- Local geometry calculations for drawn, pin-radius, KML/KMZ, GeoJSON, and DXF-derived boundaries.
 - Local deterministic report templates; no large LLM is required for this prototype.
 
 ## Boundary Accuracy
 
-Drawn map boundaries are approximate because OSM street tiles are not precise plot-tracing tools. Upload CAD/DXF or GeoJSON when a better boundary source is available. CAD boundaries are only as reliable as the uploaded drawing, and local CAD coordinates must be anchored before public climate/map layers can be interpreted.
+Drawn map boundaries are approximate because OSM street tiles are not precise plot-tracing tools. Upload CAD/DXF, KML/KMZ, or GeoJSON when a better boundary source is available. CAD boundaries are only as reliable as the uploaded drawing, and local CAD coordinates must be anchored before public climate/map layers can be interpreted.
 
 ## Run Locally
 

app.py

@@ -18,15 +18,19 @@ from src.export import write_markdown_export
 from src.geocoding import reverse_geocode_site
 from src.geojson_parser import parse_geojson_file
 from src.geometry import normalize_map_state, selection_from_lat_lon
+from src.kml_parser import parse_kml_file
 from src.location import extract_coordinates_from_text
 from src.models import BoundaryCandidate, ReportBundle, SiteSelection
 from src.osm_context import fetch_osm_context
 from src.report import build_board_bundle, build_markdown_report
+from src.soil import fetch_soil
 from src.sun import summarize_sun_wind
+from src.topography import fetch_topography
 from src.upload_limits import (
     MAX_BOARD_PREVIEW_MB,
     MAX_DXF_MB,
     MAX_GEOJSON_MB,
+    MAX_KML_MB,
     MAX_PDF_REFERENCE_MB,
     validate_upload,
 )
@@ -155,6 +159,7 @@ def generate_site_analysis(
     selected_candidate_id: str,
     dxf_state: dict[str, Any] | None,
     geojson_file: Any,
+    kml_file: Any,
     pdf_file: Any,
 ):
     reset_evidence_counter()
@@ -167,6 +172,7 @@ def generate_site_analysis(
             selected_candidate_id=selected_candidate_id,
             dxf_state=dxf_state,
             geojson_file=geojson_file,
+            kml_file=kml_file,
         )
         warnings.extend(setup_warnings)
     except Exception as exc:  # noqa: BLE001
@@ -221,6 +227,8 @@ def generate_site_analysis(
     lat, lon = selection.anchor_lat, selection.anchor_lon
     climate: dict[str, Any] = {"forecast": None, "recent_historical": None, "climate_normal": None}
     osm_context: dict[str, Any] = {"counts": {}, "features": []}
+    topography: dict[str, Any] = {}
+    soil: dict[str, Any] = {}
     site_identity: dict[str, Any] | None = None
     sun_summary: dict[str, str] = {
         "orientation_note": "Sun/orientation summary unavailable because no anchor coordinate is available.",
@@ -238,8 +246,12 @@ def generate_site_analysis(
         evidence.extend(sun_evidence)
         osm_context, osm_evidence = fetch_osm_context(selection)
         evidence.extend(osm_evidence)
+        topography, topography_evidence = fetch_topography(selection)
+        evidence.extend(topography_evidence)
+        soil, soil_evidence = fetch_soil(selection)
+        evidence.extend(soil_evidence)
     else:
-        warnings.append("No anchor coordinate was available, so climate, sun, and OSM public-data layers were skipped.")
+        warnings.append("No anchor coordinate was available, so climate, sun, OSM, terrain, and soil public-data layers were skipped.")
 
     diagram_paths = create_diagrams(selection, climate, osm_context, sun_summary)
     if len(diagram_paths) < 3:
@@ -256,6 +268,8 @@ def generate_site_analysis(
         site_identity=site_identity,
         evidence_rows=evidence,
         diagram_paths=diagram_paths,
+        topography=topography,
+        soil=soil,
         warnings=warnings,
     )
     if boundary_source:
@@ -278,6 +292,8 @@ def generate_site_analysis(
         evidence_rows=evidence,
         diagram_paths=diagram_paths,
         warnings=warnings,
+        topography=topography,
+        soil=soil,
     )
     evidence_html = evidence_to_html_table(evidence)
     padded_paths = diagram_paths + [None] * (3 - len(diagram_paths))
@@ -304,6 +320,7 @@ def _build_selection(
     selected_candidate_id: str,
     dxf_state: dict[str, Any] | None,
     geojson_file: Any,
+    kml_file: Any,
 ) -> tuple[SiteSelection, list[Any], list[str]]:
     evidence = []
     warnings = []
@@ -384,6 +401,31 @@ def _build_selection(
         )
         return selection, evidence, warnings
 
+    if kml_file:
+        kml_path = validate_upload(
+            _file_path(kml_file),
+            allowed_suffixes={".kml", ".kmz"},
+            max_mb=MAX_KML_MB,
+            label="KML/KMZ",
+        )
+        selection = parse_kml_file(kml_path)
+        evidence.append(
+            make_evidence(
+                category="Boundary",
+                finding="KML/KMZ boundary was uploaded and treated as Google Earth / WGS84 geometry.",
+                source_name=kml_path.name,
+                source_url="",
+                source_type="uploaded KML/KMZ",
+                resolution_or_scope="uploaded polygon; Google Earth/GIS-style coordinates",
+                confidence="medium",
+                limitation="Boundary is only as reliable as the exported KML/KMZ source and is not legal/cadastral verification.",
+                design_implication="Use for boundary-based first-pass site analysis and board generation.",
+                verification_needed="Confirm with faculty CAD, survey, or official project documents.",
+                output_label="user_input",
+            )
+        )
+        return selection, evidence, warnings
+
     try:
         if map_state and map_state.strip() and map_state.strip() != "{}":
             selection = normalize_map_state(map_state)
@@ -473,7 +515,7 @@ def build_app() -> gr.Blocks:
                   <p class="app-subtitle">A boundary-first analysis workspace for architecture students: map or upload a site, pull open context data, generate cited diagrams, and leave every risky claim for site verification.</p>
                 </div>
                 <div class="status-stack" aria-label="Product safeguards">
-                  <div><b>Open data</b><span>OSM, Open-Meteo, local geometry</span></div>
+                  <div><b>Open data</b><span>OSM, Open-Meteo, OpenTopoData, SoilGrids</span></div>
                   <div><b>Evidence first</b><span>source, scope, confidence, limits</span></div>
                   <div><b>No unsafe claims</b><span>site visit and professional checks stay explicit</span></div>
                 </div>
@@ -484,7 +526,7 @@ def build_app() -> gr.Blocks:
         gr.HTML(
             """
             <div class="workflow-strip">
-              <div><b>01</b><span>Select site</span><small>map, pin, DXF, GeoJSON</small></div>
+              <div><b>01</b><span>Select site</span><small>map, pin, DXF, KML/KMZ, GeoJSON</small></div>
               <div><b>02</b><span>Identify place</span><small>coordinates and approximate address</small></div>
               <div><b>03</b><span>Analyze context</span><small>climate, sun, roads, water, green context</small></div>
               <div><b>04</b><span>Export board pack</span><small>diagrams, evidence, checklist, markdown</small></div>
@@ -524,15 +566,17 @@ def build_app() -> gr.Blocks:
                         <li>Boundary metrics: area, perimeter, input mode, accuracy label</li>
                         <li>Climate views: forecast/current, recent historical, climate-normal style</li>
                         <li>Context: OSM roads, water, green space, amenities where mapped</li>
+                        <li>Terrain and soil: OpenTopoData elevation and SoilGrids preliminary topsoil signals</li>
                         <li>Output: presentation board PNG/PDF, diagrams, evidence table, checklist, Markdown report</li>
                       </ul>
                     </div>
                     """
                 )
-        with gr.Accordion("Optional uploads for MVP: CAD / GeoJSON / PDF reference", open=True, elem_classes=["upload-panel"]):
+        with gr.Accordion("Optional uploads for MVP: CAD / Google Earth KML / GeoJSON / PDF reference", open=True, elem_classes=["upload-panel"]):
             with gr.Row():
                 dxf_file = gr.File(label="DXF upload", file_types=[".dxf"], type="filepath")
                 geojson_file = gr.File(label="GeoJSON upload", file_types=[".geojson", ".json"], type="filepath")
+                kml_file = gr.File(label="Google Earth KML/KMZ upload", file_types=[".kml", ".kmz"], type="filepath")
                 pdf_file = gr.File(label="PDF reference only", file_types=[".pdf"], type="filepath")
             dxf_candidate = gr.Dropdown(label="DXF boundary candidate", choices=[], interactive=True)
             dxf_summary = gr.Markdown("Upload a DXF to inspect boundary candidates.")
@@ -580,6 +624,7 @@ def build_app() -> gr.Blocks:
                 dxf_candidate,
                 dxf_state,
                 geojson_file,
+                kml_file,
                 pdf_file,
             ],
             outputs=[

assets/map.js

@@ -208,7 +208,7 @@ function requestLeafletFallback() {
   script.onload = () => initSiteMap();
   script.onerror = () => {
     if (status) {
-      status.textContent = "Map library could not load. Use the lat/lon field or upload DXF/GeoJSON, then generate the report.";
+      status.textContent = "Map library could not load. Use the lat/lon field or upload DXF/KML/GeoJSON, then generate the report.";
     }
   };
   document.head.appendChild(script);
@@ -227,7 +227,7 @@ function waitForLeafletAndInit(attempt = 0) {
   if (attempt > 80) {
     const status = document.getElementById("map-status");
     if (status) {
-      status.textContent = "Map could not initialize. Use the lat/lon field or upload DXF/GeoJSON, then generate the report.";
+      status.textContent = "Map could not initialize. Use the lat/lon field or upload DXF/KML/GeoJSON, then generate the report.";
     }
     return;
   }

src/board_export.py

@@ -38,6 +38,8 @@ def create_board_artifacts(
     evidence_rows: Iterable[EvidenceItem],
     diagram_paths: list[str],
     warnings: list[str],
+    topography: dict[str, Any] | None = None,
+    soil: dict[str, Any] | None = None,
 ) -> dict[str, str]:
     out_dir = Path(tempfile.mkdtemp(prefix="sis_board_"))
     png_path = out_dir / "site-intelligence-presentation-board.png"
@@ -96,10 +98,10 @@ def create_board_artifacts(
         line_spacing=8,
     )
 
-    _panel(draw, (965, 778, 1575, 1158), "04 Design cues", fonts)
+    _panel(draw, (965, 778, 1575, 1158), "04 Terrain, ground and design cues", fonts)
     _draw_bullets(
         draw,
-        _design_cues(selection, osm_context, culture_notes),
+        _design_cues(selection, osm_context, culture_notes, topography, soil),
         (995, 850, 1545, 1112),
         fonts["body"],
         INK_2,
@@ -270,7 +272,7 @@ def _draw_wrapped_text(
         lines.append(line)
     if max_lines is not None and len(lines) > max_lines:
         lines = lines[:max_lines]
-        lines[-1] = _clip(lines[-1], max(8, len(lines[-1]) - 3)) + "..."
+        lines[-1] = _ellipsize_to_width(draw, lines[-1], font, x2 - x1)
     y = y1
     line_height = draw.textbbox((0, 0), "Ag", font=font)[3] + line_spacing
     for line in lines:
@@ -370,7 +372,13 @@ def _sun_caption(sun_summary: dict[str, str]) -> str:
     return " ".join(piece for piece in pieces if piece)
 
 
-def _design_cues(selection: SiteSelection, osm_context: dict[str, Any], culture_notes: str) -> list[str]:
+def _design_cues(
+    selection: SiteSelection,
+    osm_context: dict[str, Any],
+    culture_notes: str,
+    topography: dict[str, Any] | None,
+    soil: dict[str, Any] | None,
+) -> list[str]:
     counts = osm_context.get("counts") or {}
     cues = [
         "Treat west and afternoon exposure as a shading and glare item to test in massing.",
@@ -378,6 +386,12 @@ def _design_cues(selection: SiteSelection, osm_context: dict[str, Any], culture_
         "Check drainage, waterlogging, runoff, and low points during the site visit.",
         "Keep soil and foundation language as professional-verification prompts, not recommendations.",
     ]
+    terrain_cue = _terrain_cue(topography)
+    if terrain_cue:
+        cues.insert(0, terrain_cue)
+    soil_cue = _soil_cue(soil)
+    if soil_cue:
+        cues.insert(1, soil_cue)
     if counts.get("natural/water") or counts.get("water"):
         cues.insert(1, "Mapped water context should trigger edge, flood, drainage, humidity, and view checks.")
     if counts.get("leisure/green") or counts.get("natural/wood"):
@@ -389,6 +403,23 @@ def _design_cues(selection: SiteSelection, osm_context: dict[str, Any], culture_
     return cues
 
 
+def _terrain_cue(topography: dict[str, Any] | None) -> str | None:
+    if not topography:
+        return "Terrain data unavailable; use CAD contours, site levels, and drainage observation."
+    relief = topography.get("relief_m")
+    slope = topography.get("approx_slope_pct")
+    if relief is None and slope is None:
+        return "Public terrain sampling is incomplete; verify slope and drainage manually."
+    return f"Terrain: relief {relief} m, sampled slope {slope}%; verify contours and drainage."
+
+
+def _soil_cue(soil: dict[str, Any] | None) -> str | None:
+    if not soil:
+        return "Soil data unavailable; request geotechnical/professional ground information."
+    texture = soil.get("texture_signal", "soil texture signal")
+    return f"SoilGrids: {texture}; professional ground verification only."
+
+
 def _verification_items(evidence_rows: list[EvidenceItem], warnings: list[str]) -> list[str]:
     items = [
         "Confirm actual plot edges with CAD, KML, GeoJSON, faculty drawing, or site survey.",
@@ -413,3 +444,13 @@ def _verification_items(evidence_rows: list[EvidenceItem], warnings: list[str])
 def _clip(text: object, limit: int) -> str:
     value = "" if text is None else str(text)
     return value if len(value) <= limit else value[: max(0, limit - 3)].rstrip() + "..."
+
+
+def _ellipsize_to_width(draw: ImageDraw.ImageDraw, text: str, font: ImageFont.ImageFont, width: int) -> str:
+    ellipsis = "..."
+    value = text.rstrip()
+    if draw.textbbox((0, 0), value, font=font)[2] <= width:
+        return value
+    while value and draw.textbbox((0, 0), value + ellipsis, font=font)[2] > width:
+        value = value[:-1].rstrip()
+    return (value or text[:1]) + ellipsis

src/diagrams.py

@@ -174,9 +174,25 @@ def create_context_diagram(selection: SiteSelection, osm_context: dict[str, Any]
         ax.scatter([selection.anchor_lon], [selection.anchor_lat], color="#b55a3d", s=70, zorder=3)
         ax.set_xlim(selection.anchor_lon - radius_deg * 1.4, selection.anchor_lon + radius_deg * 1.4)
         ax.set_ylim(selection.anchor_lat - radius_deg * 1.4, selection.anchor_lat + radius_deg * 1.4)
+    feature_points = _osm_feature_points(osm_context.get("features") or [])
+    for label, color, marker in (
+        ("roads/access", "#66736f", "."),
+        ("water", "#245a93", "s"),
+        ("green/open", "#2f7d59", "^"),
+        ("amenity", "#d9972b", "o"),
+        ("landuse", "#7c6b57", "x"),
+    ):
+        coords = feature_points.get(label, [])
+        if not coords:
+            continue
+        xs = [lon for lon, _ in coords[:40]]
+        ys = [lat for _, lat in coords[:40]]
+        ax.scatter(xs, ys, s=34 if marker != "." else 20, color=color, marker=marker, alpha=0.82, label=label, zorder=4)
     counts = osm_context.get("counts") or {}
     summary = "\n".join(f"{key}: {value}" for key, value in list(counts.items())[:7]) or "OSM context unavailable or sparse."
     ax.text(0.03, 0.96, summary, transform=ax.transAxes, va="top", ha="left", fontsize=9.5, color="#101817", bbox={"facecolor": "white", "alpha": 0.88, "edgecolor": "#c8d0cc", "boxstyle": "round,pad=0.45"})
+    if feature_points:
+        ax.legend(loc="lower right", fontsize=7.5, frameon=True, facecolor="white", edgecolor="#c8d0cc")
     ax.text(0.94, 0.93, "N", transform=ax.transAxes, ha="center", fontsize=12, fontweight="bold", color="#101817")
     ax.arrow(0.94, 0.82, 0, 0.08, transform=ax.transAxes, width=0.004, color="#101817", length_includes_head=True, head_width=0.025, head_length=0.035)
     ax.set_title("Geographic context - preliminary", loc="left", fontsize=14, fontweight="bold", color="#101817", pad=12)
@@ -190,3 +206,36 @@ def create_context_diagram(selection: SiteSelection, osm_context: dict[str, Any]
     fig.savefig(output_path, bbox_inches="tight")
     plt.close(fig)
     return output_path
+
+
+def _osm_feature_points(features: list[dict[str, Any]]) -> dict[str, list[tuple[float, float]]]:
+    buckets: dict[str, list[tuple[float, float]]] = {
+        "roads/access": [],
+        "water": [],
+        "green/open": [],
+        "amenity": [],
+        "landuse": [],
+    }
+    for feature in features:
+        lat, lon = _feature_center(feature)
+        if lat is None or lon is None:
+            continue
+        tags = feature.get("tags") or {}
+        if "highway" in tags:
+            buckets["roads/access"].append((lon, lat))
+        elif tags.get("natural") == "water" or "waterway" in tags:
+            buckets["water"].append((lon, lat))
+        elif tags.get("leisure") == "park" or tags.get("landuse") in {"forest", "grass", "recreation_ground"}:
+            buckets["green/open"].append((lon, lat))
+        elif "amenity" in tags:
+            buckets["amenity"].append((lon, lat))
+        elif "landuse" in tags:
+            buckets["landuse"].append((lon, lat))
+    return {key: value for key, value in buckets.items() if value}
+
+
+def _feature_center(feature: dict[str, Any]) -> tuple[float | None, float | None]:
+    if feature.get("type") == "node":
+        return feature.get("lat"), feature.get("lon")
+    center = feature.get("center") or {}
+    return center.get("lat"), center.get("lon")

src/kml_parser.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import uuid
+import zipfile
+from pathlib import Path
+from typing import Any
+from xml.etree import ElementTree as ET
+
+from .geometry import calculate_site_metrics
+from .models import SiteSelection
+
+
+def parse_kml_file(path: str | Path) -> SiteSelection:
+    source = Path(path)
+    xml_text = _read_kml_text(source)
+    root = ET.fromstring(xml_text)
+    polygons = _extract_polygons(root)
+    if not polygons:
+        raise ValueError("KML/KMZ must contain at least one Polygon boundary.")
+    geometry = _largest_polygon(polygons)
+    metrics = calculate_site_metrics(geometry)
+    return SiteSelection(
+        id=f"S-{uuid.uuid4().hex[:8]}",
+        selection_type="kml_boundary",
+        coordinate_mode="wgs84",
+        geometry_geojson=geometry,
+        local_geometry=None,
+        anchor_lat=metrics["centroid"][0],
+        anchor_lon=metrics["centroid"][1],
+        radius_m=None,
+        area_sqm=metrics["area_sqm"],
+        perimeter_m=metrics["perimeter_m"],
+        centroid=metrics["centroid"],
+        bbox=metrics["bbox"],
+        unit_source="Google Earth / KML WGS84 coordinates",
+        accuracy_label="uploaded Google Earth/KML boundary",
+        source_files=[source.name],
+        selected_boundary_id=None,
+        limitations=[
+            "KML/KMZ geometry is treated as a user-exported Google Earth or GIS boundary.",
+            "It is not legal/cadastral boundary verification.",
+            "Verify against faculty CAD, survey, or project documents before plot-level decisions.",
+        ],
+    )
+
+
+def _read_kml_text(source: Path) -> str:
+    suffix = source.suffix.lower()
+    if suffix == ".kml":
+        return source.read_text(encoding="utf-8-sig")
+    if suffix == ".kmz":
+        with zipfile.ZipFile(source) as archive:
+            kml_names = [name for name in archive.namelist() if name.lower().endswith(".kml")]
+            if not kml_names:
+                raise ValueError("KMZ archive does not contain a KML file.")
+            with archive.open(kml_names[0]) as handle:
+                return handle.read().decode("utf-8-sig")
+    raise ValueError("KML parser supports only .kml and .kmz files.")
+
+
+def _extract_polygons(root: ET.Element) -> list[dict[str, Any]]:
+    polygons: list[dict[str, Any]] = []
+    for polygon in root.iter():
+        if not _tag_endswith(polygon.tag, "Polygon"):
+            continue
+        coordinates_text = None
+        for child in polygon.iter():
+            if _tag_endswith(child.tag, "coordinates") and child.text:
+                coordinates_text = child.text
+                break
+        if not coordinates_text:
+            continue
+        ring = _parse_coordinates(coordinates_text)
+        if len(ring) >= 4:
+            polygons.append({"type": "Polygon", "coordinates": [ring]})
+    return polygons
+
+
+def _parse_coordinates(text: str) -> list[list[float]]:
+    points: list[list[float]] = []
+    for token in text.replace("\n", " ").replace("\t", " ").split():
+        parts = [part for part in token.split(",") if part != ""]
+        if len(parts) < 2:
+            continue
+        lon = float(parts[0])
+        lat = float(parts[1])
+        if not (-180 <= lon <= 180 and -90 <= lat <= 90):
+            raise ValueError("KML coordinates do not look like WGS84 longitude/latitude.")
+        points.append([lon, lat])
+    if points and points[0] != points[-1]:
+        points.append(points[0])
+    return points
+
+
+def _largest_polygon(polygons: list[dict[str, Any]]) -> dict[str, Any]:
+    scored = []
+    for geometry in polygons:
+        try:
+            scored.append((calculate_site_metrics(geometry)["area_sqm"] or 0, geometry))
+        except Exception:
+            continue
+    if not scored:
+        raise ValueError("KML polygons could not be converted to valid site geometry.")
+    return max(scored, key=lambda item: item[0])[1]
+
+
+def _tag_endswith(tag: str, suffix: str) -> bool:
+    return tag.endswith("}" + suffix) or tag == suffix

src/models.py

@@ -10,6 +10,7 @@ SelectionType = Literal[
     "pin_radius",
     "dxf_boundary",
     "geojson_boundary",
+    "kml_boundary",
     "reference_only",
 ]
 CoordinateMode = Literal["wgs84", "local_cad", "anchored_local_cad", "unknown"]

src/report.py

@@ -15,9 +15,21 @@ def build_board_bundle(
     site_identity: dict | None,
     evidence_rows,
     diagram_paths: list[str],
+    topography: dict | None = None,
+    soil: dict | None = None,
     warnings: list[str] | None = None,
 ) -> ReportBundle:
-    board = build_board_markdown(project_name, site_name, selection, climate, osm_context, sun_summary, site_identity)
+    board = build_board_markdown(
+        project_name,
+        site_name,
+        selection,
+        climate,
+        osm_context,
+        sun_summary,
+        site_identity,
+        topography=topography,
+        soil=soil,
+    )
     checklist = build_site_visit_checklist()
     bundle = ReportBundle(
         board_markdown=board,
@@ -38,6 +50,8 @@ def build_board_markdown(
     osm_context: dict,
     sun_summary: dict[str, str],
     site_identity: dict | None = None,
+    topography: dict | None = None,
+    soil: dict | None = None,
 ) -> str:
     area = _fmt(selection.area_sqm, "sqm")
     perimeter = _fmt(selection.perimeter_m, "m")
@@ -71,6 +85,12 @@ def build_board_markdown(
 
 {context_text}
 
+### Terrain / Soil Signals
+
+{_topography_summary(topography)}
+
+{_soil_summary(soil)}
+
 ### Sun / Wind
 
 - {sun_summary.get("orientation_note", "Orientation summary unavailable.")}
@@ -85,7 +105,7 @@ def build_board_markdown(
 - Treat water, green, built-up, and amenity context as source-backed only where evidence rows exist.
 - Keep culture/demographic context as editable field observations unless supported by reliable sources.
 
-{build_detailed_site_analysis(selection, climate, osm_context, sun_summary, site_identity)}
+{build_detailed_site_analysis(selection, climate, osm_context, sun_summary, site_identity, topography, soil)}
 """
 
 
@@ -95,6 +115,8 @@ def build_detailed_site_analysis(
     osm_context: dict,
     sun_summary: dict[str, str],
     site_identity: dict | None,
+    topography: dict | None = None,
+    soil: dict | None = None,
 ) -> str:
     context_counts = osm_context.get("counts") or {}
     current = climate.get("forecast") or {}
@@ -198,7 +220,8 @@ These references are used as learning/checklist references only. They are not tr
 **What the app can support now**
 
 - The current prototype records mapped green/water features where OSM data is available.
-- It does not yet run DEM slope, contour extraction, flood-risk, NDVI, or tree-canopy analysis.
+{_topography_summary(topography)}
+- It does not yet run contour extraction, flood-risk, NDVI, or tree-canopy analysis.
 
 **Why it matters**
 
@@ -362,6 +385,7 @@ These references are used as learning/checklist references only. They are not tr
 
 **What the app says safely**
 
+{_soil_summary(soil)}
 - This prototype does not generate final soil or foundation recommendations.
 - Soil/foundation is treated as a professional-verification item.
 
@@ -475,6 +499,35 @@ def _context_count_lines(context_counts: dict) -> str:
     return "\n".join(lines)
 
 
+def _topography_summary(topography: dict | None) -> str:
+    if not topography:
+        return "- Topography/elevation unavailable in this run; verify slope, contours, drainage, and low points manually."
+    mean_elev = topography.get("mean_elevation_m", "n/a")
+    relief = topography.get("relief_m", "n/a")
+    slope = topography.get("approx_slope_pct", "n/a")
+    interpretation = topography.get("interpretation", "Use only as preliminary terrain context.")
+    return (
+        f"- Public elevation signal: mean {mean_elev} m, sampled relief {relief} m, "
+        f"approximate sampled slope {slope}%. {interpretation}"
+    )
+
+
+def _soil_summary(soil: dict | None) -> str:
+    if not soil:
+        return "- Soil signal unavailable in this run; use geotechnical report, local engineer input, or official soil maps."
+    pieces = [soil.get("texture_signal", "soil texture signal unavailable")]
+    if soil.get("clay_pct") is not None:
+        pieces.append(f"clay {soil['clay_pct']}%")
+    if soil.get("sand_pct") is not None:
+        pieces.append(f"sand {soil['sand_pct']}%")
+    if soil.get("silt_pct") is not None:
+        pieces.append(f"silt {soil['silt_pct']}%")
+    if soil.get("ph_h2o") is not None:
+        pieces.append(f"pH {soil['ph_h2o']}")
+    implication = soil.get("design_implication", "Use only as a preliminary prompt for soil verification.")
+    return "- Preliminary SoilGrids signal: " + ", ".join(pieces) + f". {implication}"
+
+
 def _climate_summary_lines(climate: dict) -> str:
     forecast = climate.get("forecast") or {}
     recent = climate.get("recent_historical") or {}

src/soil.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .evidence import make_evidence
+from .http_client import get_json
+from .models import EvidenceItem, SiteSelection
+
+SOILGRIDS_URL = "https://rest.isric.org/soilgrids/v2.0/properties/query"
+
+
+def fetch_soil(selection: SiteSelection) -> tuple[dict[str, Any], list[EvidenceItem]]:
+    if selection.anchor_lat is None or selection.anchor_lon is None:
+        return {}, [
+            make_evidence(
+                category="Soil / ground",
+                finding="SoilGrids lookup was skipped because no real-world site coordinate is available.",
+                source_name="SoilGrids / ISRIC",
+                source_url="https://docs.isric.org/globaldata/soilgrids/",
+                source_type="global soil model",
+                resolution_or_scope="not available",
+                confidence="low",
+                limitation="Soil lookup needs a WGS84 coordinate.",
+                design_implication="Use field/geotechnical verification before any soil-related design assumptions.",
+                verification_needed="Provide a map/KML/GeoJSON boundary or anchor coordinate.",
+                output_label="professional_verification_required",
+            )
+        ]
+    try:
+        data = get_json(
+            SOILGRIDS_URL,
+            {
+                "lon": selection.anchor_lon,
+                "lat": selection.anchor_lat,
+                "property": ["clay", "sand", "silt", "phh2o", "bdod", "soc"],
+                "depth": "0-5cm",
+                "value": "mean",
+            },
+            timeout=30,
+        )
+        values = _extract_soil_values(data)
+        soil = _interpret_soil(values)
+        return soil, [
+            make_evidence(
+                category="Soil / ground",
+                finding=_soil_finding(soil),
+                source_name="SoilGrids / ISRIC",
+                source_url="https://docs.isric.org/globaldata/soilgrids/",
+                source_type="global soil model",
+                resolution_or_scope="anchor coordinate; 0-5 cm modelled topsoil properties",
+                confidence="low",
+                limitation="SoilGrids is coarse global model data, not plot-level geotechnical testing or bearing-capacity evidence.",
+                design_implication=soil.get("design_implication", "Use only as a ground-condition prompt."),
+                verification_needed="Obtain site-specific geotechnical/professional verification before foundation or excavation decisions.",
+                output_label="professional_verification_required",
+            )
+        ]
+    except Exception as exc:  # noqa: BLE001
+        return {}, [
+            make_evidence(
+                category="Soil / ground",
+                finding="SoilGrids soil properties could not be retrieved.",
+                source_name="SoilGrids / ISRIC",
+                source_url="https://docs.isric.org/globaldata/soilgrids/",
+                source_type="global soil model",
+                resolution_or_scope="not available",
+                confidence="low",
+                limitation=f"SoilGrids request failed: {type(exc).__name__}.",
+                design_implication="Do not infer soil type from this missing layer.",
+                verification_needed="Use geotechnical report, soil test, local engineer input, or official soil maps.",
+                output_label="professional_verification_required",
+            )
+        ]
+
+
+def _extract_soil_values(data: dict[str, Any]) -> dict[str, float | None]:
+    values: dict[str, float | None] = {}
+    for layer in data.get("properties", {}).get("layers", []):
+        name = layer.get("name")
+        depths = layer.get("depths") or []
+        if not name or not depths:
+            continue
+        mean = (depths[0].get("values") or {}).get("mean")
+        values[name] = float(mean) if mean is not None else None
+    return values
+
+
+def _interpret_soil(values: dict[str, float | None]) -> dict[str, Any]:
+    clay_pct = _gkg_to_pct(values.get("clay"))
+    sand_pct = _gkg_to_pct(values.get("sand"))
+    silt_pct = _gkg_to_pct(values.get("silt"))
+    ph = _ph_value(values.get("phh2o"))
+    texture = "mixed or uncertain texture"
+    implication = "Use as a preliminary prompt for soil verification; do not make foundation decisions from this layer."
+    if clay_pct is not None and clay_pct >= 35:
+        texture = "clay-heavy topsoil signal"
+        implication = "Check drainage, shrink-swell behaviour, water retention, and settlement risk with professional testing."
+    elif sand_pct is not None and sand_pct >= 55:
+        texture = "sandy topsoil signal"
+        implication = "Check drainage, erosion, excavation stability, and bearing conditions with professional testing."
+    elif silt_pct is not None and silt_pct >= 45:
+        texture = "silt-heavy topsoil signal"
+        implication = "Check waterlogging, compaction, erosion, and drainage behaviour with professional testing."
+    return {
+        "texture_signal": texture,
+        "clay_pct": clay_pct,
+        "sand_pct": sand_pct,
+        "silt_pct": silt_pct,
+        "ph_h2o": ph,
+        "bulk_density_raw": values.get("bdod"),
+        "soc_raw": values.get("soc"),
+        "design_implication": implication,
+        "safe_note": "Preliminary SoilGrids model output only; verify with geotechnical/professional sources.",
+    }
+
+
+def _soil_finding(soil: dict[str, Any]) -> str:
+    parts = [soil.get("texture_signal") or "soil texture signal unavailable"]
+    if soil.get("clay_pct") is not None:
+        parts.append(f"clay {soil['clay_pct']}%")
+    if soil.get("sand_pct") is not None:
+        parts.append(f"sand {soil['sand_pct']}%")
+    if soil.get("silt_pct") is not None:
+        parts.append(f"silt {soil['silt_pct']}%")
+    if soil.get("ph_h2o") is not None:
+        parts.append(f"pH {soil['ph_h2o']}")
+    return "SoilGrids preliminary topsoil signal: " + ", ".join(parts) + "."
+
+
+def _gkg_to_pct(value: float | None) -> float | None:
+    return round(value / 10, 1) if value is not None else None
+
+
+def _ph_value(value: float | None) -> float | None:
+    return round(value / 10, 1) if value is not None else None

src/topography.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import math
+from statistics import mean
+from typing import Any
+
+from .evidence import make_evidence
+from .geometry import EARTH_RADIUS_M
+from .http_client import get_json
+from .models import EvidenceItem, SiteSelection
+
+OPENTOPO_URL = "https://api.opentopodata.org/v1/srtm90m"
+
+
+def fetch_topography(selection: SiteSelection) -> tuple[dict[str, Any], list[EvidenceItem]]:
+    points = _sample_points(selection)
+    if not points:
+        return {}, [
+            make_evidence(
+                category="Topography",
+                finding="Topography sampling was skipped because no real-world site coordinate is available.",
+                source_name="OpenTopoData",
+                source_url="https://www.opentopodata.org/api/",
+                source_type="public elevation API",
+                resolution_or_scope="not available",
+                confidence="low",
+                limitation="Elevation needs a WGS84 coordinate.",
+                design_implication="Use user/CAD contour notes until the site is georeferenced.",
+                verification_needed="Provide a map/KML/GeoJSON boundary or anchor coordinate.",
+                output_label="site_visit_required",
+            )
+        ]
+    try:
+        locations = "|".join(f"{lat:.6f},{lon:.6f}" for lat, lon in points)
+        data = get_json(OPENTOPO_URL, {"locations": locations}, timeout=25)
+        elevations = [
+            float(item["elevation"])
+            for item in data.get("results", [])
+            if item.get("elevation") is not None
+        ]
+        if not elevations:
+            raise ValueError("No elevation values returned.")
+        relief = max(elevations) - min(elevations)
+        diagonal_m = _selection_diagonal_m(selection) or max(selection.radius_m or 250, 1)
+        slope_pct = (relief / diagonal_m) * 100 if diagonal_m else None
+        topo = {
+            "source": "OpenTopoData SRTM 90m",
+            "sample_count": len(elevations),
+            "min_elevation_m": round(min(elevations), 1),
+            "max_elevation_m": round(max(elevations), 1),
+            "mean_elevation_m": round(mean(elevations), 1),
+            "relief_m": round(relief, 1),
+            "approx_slope_pct": round(slope_pct, 2) if slope_pct is not None else None,
+            "interpretation": _topography_interpretation(relief, slope_pct),
+        }
+        return topo, [
+            make_evidence(
+                category="Topography",
+                finding=(
+                    f"Elevation sampling found mean elevation {topo['mean_elevation_m']} m "
+                    f"and approximate relief {topo['relief_m']} m across sampled points."
+                ),
+                source_name="OpenTopoData SRTM 90m",
+                source_url="https://www.opentopodata.org/api/",
+                source_type="public elevation API",
+                resolution_or_scope="sampled centroid and boundary/bbox points; SRTM-scale terrain",
+                confidence="medium",
+                limitation="SRTM/OpenTopoData is not a site survey and may miss small plot-level slopes, steps, retaining walls, and drains.",
+                design_implication="Use for early slope/drainage awareness and decide what to verify on site.",
+                verification_needed="Check actual slope, contours, waterlogging, retaining edges, and drainage outlets during site visit.",
+                output_label="public_data",
+            )
+        ]
+    except Exception as exc:  # noqa: BLE001
+        return {}, [
+            make_evidence(
+                category="Topography",
+                finding="Topography/elevation data could not be retrieved.",
+                source_name="OpenTopoData",
+                source_url="https://www.opentopodata.org/api/",
+                source_type="public elevation API",
+                resolution_or_scope="not available",
+                confidence="low",
+                limitation=f"API request failed: {type(exc).__name__}.",
+                design_implication="Do not infer slope or drainage direction from this missing layer.",
+                verification_needed="Use CAD contours, survey levels, site observation, or another DEM source.",
+                output_label="site_visit_required",
+            )
+        ]
+
+
+def _sample_points(selection: SiteSelection) -> list[tuple[float, float]]:
+    points: list[tuple[float, float]] = []
+    if selection.anchor_lat is not None and selection.anchor_lon is not None:
+        points.append((selection.anchor_lat, selection.anchor_lon))
+    if selection.bbox:
+        min_lon, min_lat, max_lon, max_lat = selection.bbox
+        points.extend(
+            [
+                (min_lat, min_lon),
+                (min_lat, max_lon),
+                (max_lat, min_lon),
+                (max_lat, max_lon),
+                ((min_lat + max_lat) / 2, min_lon),
+                ((min_lat + max_lat) / 2, max_lon),
+            ]
+        )
+    return _dedupe(points)[:8]
+
+
+def _dedupe(points: list[tuple[float, float]]) -> list[tuple[float, float]]:
+    seen = set()
+    out = []
+    for lat, lon in points:
+        key = (round(lat, 6), round(lon, 6))
+        if key not in seen:
+            seen.add(key)
+            out.append((lat, lon))
+    return out
+
+
+def _selection_diagonal_m(selection: SiteSelection) -> float | None:
+    if not selection.bbox:
+        return None
+    min_lon, min_lat, max_lon, max_lat = selection.bbox
+    return _distance_m(min_lat, min_lon, max_lat, max_lon)
+
+
+def _distance_m(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    phi1 = math.radians(lat1)
+    phi2 = math.radians(lat2)
+    dphi = math.radians(lat2 - lat1)
+    dlambda = math.radians(lon2 - lon1)
+    a = math.sin(dphi / 2) ** 2 + math.cos(phi1) * math.cos(phi2) * math.sin(dlambda / 2) ** 2
+    return 2 * EARTH_RADIUS_M * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+
+
+def _topography_interpretation(relief_m: float, slope_pct: float | None) -> str:
+    if slope_pct is None:
+        return "Elevation was sampled, but slope could not be estimated."
+    if relief_m < 1.0 and slope_pct < 1.0:
+        return "Public elevation samples suggest a broadly flat site, but micro-drainage still needs site verification."
+    if slope_pct < 3.0:
+        return "Public elevation samples suggest a gentle level change; verify drainage and accessible-route gradients."
+    return "Public elevation samples suggest meaningful level change; verify contours, cut-fill, drainage, and retaining edges."

src/upload_limits.py

@@ -6,6 +6,7 @@ from typing import Iterable
 
 MAX_DXF_MB = 10
 MAX_GEOJSON_MB = 5
+MAX_KML_MB = 8
 MAX_PDF_REFERENCE_MB = 15
 MAX_BOARD_PREVIEW_MB = 12
 

tests/test_kml_parser.py

@@ -0,0 +1,65 @@
+import tempfile
+import unittest
+import zipfile
+from pathlib import Path
+
+from src.kml_parser import parse_kml_file
+
+
+KML_TEXT = """<?xml version="1.0" encoding="UTF-8"?>
+<kml xmlns="http://www.opengis.net/kml/2.2">
+  <Document>
+    <Placemark>
+      <name>Site boundary</name>
+      <Polygon>
+        <outerBoundaryIs>
+          <LinearRing>
+            <coordinates>
+              70.2450,21.0020,0 70.2460,21.0020,0 70.2460,21.0030,0 70.2450,21.0030,0 70.2450,21.0020,0
+            </coordinates>
+          </LinearRing>
+        </outerBoundaryIs>
+      </Polygon>
+    </Placemark>
+  </Document>
+</kml>
+"""
+
+
+class KmlParserTests(unittest.TestCase):
+    def test_kml_polygon_creates_wgs84_selection(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "site.kml"
+            path.write_text(KML_TEXT, encoding="utf-8")
+
+            selection = parse_kml_file(path)
+
+        self.assertEqual(selection.selection_type, "kml_boundary")
+        self.assertEqual(selection.coordinate_mode, "wgs84")
+        self.assertGreater(selection.area_sqm or 0, 0)
+        self.assertAlmostEqual(selection.anchor_lat or 0, 21.0024, places=3)
+        self.assertAlmostEqual(selection.anchor_lon or 0, 70.2454, places=3)
+        self.assertIn("legal/cadastral", " ".join(selection.limitations))
+
+    def test_kmz_polygon_creates_selection(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "site.kmz"
+            with zipfile.ZipFile(path, "w") as archive:
+                archive.writestr("doc.kml", KML_TEXT)
+
+            selection = parse_kml_file(path)
+
+        self.assertEqual(selection.selection_type, "kml_boundary")
+        self.assertEqual(selection.source_files, ["site.kmz"])
+
+    def test_kml_without_polygon_is_rejected(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "empty.kml"
+            path.write_text("<kml><Document /></kml>", encoding="utf-8")
+
+            with self.assertRaises(ValueError):
+                parse_kml_file(path)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_report.py

@@ -93,6 +93,20 @@ class ReportTests(unittest.TestCase):
             "wind_note": "Regional wind direction is modelled and needs site verification.",
             "limitation": "No surrounding-building shadow simulation.",
         }
+        topography = {
+            "mean_elevation_m": 11.2,
+            "relief_m": 3.4,
+            "approx_slope_pct": 1.2,
+            "interpretation": "Public elevation samples suggest a gentle level change.",
+        }
+        soil = {
+            "texture_signal": "clay-heavy topsoil signal",
+            "clay_pct": 42.0,
+            "sand_pct": 30.0,
+            "silt_pct": 28.0,
+            "ph_h2o": 7.2,
+            "design_implication": "Check drainage and settlement risk with professional testing.",
+        }
 
         board = build_board_markdown(
             "Resort Thesis",
@@ -102,6 +116,8 @@ class ReportTests(unittest.TestCase):
             osm_context,
             sun_summary,
             {"city": "Chorwad", "state": "Gujarat", "country": "India"},
+            topography=topography,
+            soil=soil,
         )
 
         self.assertIn("Detailed Site Analysis Workbook", board)
@@ -109,6 +125,9 @@ class ReportTests(unittest.TestCase):
         self.assertIn("Urban Design Lab", board)
         self.assertIn("Diagram And Sheet Production Checklist", board)
         self.assertIn("Before, During And After Site Visit", board)
+        self.assertIn("Public elevation signal", board)
+        self.assertIn("Preliminary SoilGrids signal", board)
+        self.assertNotIn("- -", board)
         self.assertEqual(find_forbidden_phrases(board), [])
 
 

tests/test_soil.py

@@ -0,0 +1,48 @@
+import unittest
+from unittest.mock import patch
+
+from src.geometry import selection_from_lat_lon
+from src.safety import find_forbidden_phrases
+from src.soil import fetch_soil
+
+
+def _soil_payload(clay=420, sand=300, silt=280, phh2o=72):
+    return {
+        "properties": {
+            "layers": [
+                {"name": "clay", "depths": [{"values": {"mean": clay}}]},
+                {"name": "sand", "depths": [{"values": {"mean": sand}}]},
+                {"name": "silt", "depths": [{"values": {"mean": silt}}]},
+                {"name": "phh2o", "depths": [{"values": {"mean": phh2o}}]},
+                {"name": "bdod", "depths": [{"values": {"mean": 140}}]},
+                {"name": "soc", "depths": [{"values": {"mean": 18}}]},
+            ]
+        }
+    }
+
+
+class SoilTests(unittest.TestCase):
+    def test_fetch_soil_interprets_clay_heavy_signal_safely(self):
+        selection = selection_from_lat_lon(21.002, 70.245, radius_m=250)
+        with patch("src.soil.get_json", return_value=_soil_payload()):
+            soil, evidence = fetch_soil(selection)
+
+        self.assertEqual(soil["texture_signal"], "clay-heavy topsoil signal")
+        self.assertEqual(soil["clay_pct"], 42.0)
+        self.assertEqual(soil["ph_h2o"], 7.2)
+        joined = evidence[0].finding + evidence[0].design_implication + evidence[0].verification_needed
+        self.assertIn("professional", joined)
+        self.assertEqual(find_forbidden_phrases(joined), [])
+
+    def test_fetch_soil_failure_returns_missing_data_evidence(self):
+        selection = selection_from_lat_lon(21.002, 70.245, radius_m=250)
+        with patch("src.soil.get_json", side_effect=TimeoutError("slow")):
+            soil, evidence = fetch_soil(selection)
+
+        self.assertEqual(soil, {})
+        self.assertEqual(evidence[0].confidence, "low")
+        self.assertIn("Do not infer soil type", evidence[0].design_implication)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_topography.py

@@ -0,0 +1,40 @@
+import unittest
+from unittest.mock import patch
+
+from src.geometry import selection_from_lat_lon
+from src.topography import fetch_topography
+
+
+class TopographyTests(unittest.TestCase):
+    def test_fetch_topography_summarizes_elevation_samples(self):
+        selection = selection_from_lat_lon(21.002, 70.245, radius_m=250)
+        fake_response = {
+            "results": [
+                {"elevation": 12.0},
+                {"elevation": 14.5},
+                {"elevation": 13.0},
+                {"elevation": 16.0},
+            ]
+        }
+        with patch("src.topography.get_json", return_value=fake_response):
+            topo, evidence = fetch_topography(selection)
+
+        self.assertEqual(topo["sample_count"], 4)
+        self.assertEqual(topo["min_elevation_m"], 12.0)
+        self.assertEqual(topo["max_elevation_m"], 16.0)
+        self.assertGreaterEqual(topo["relief_m"], 4.0)
+        self.assertEqual(evidence[0].category, "Topography")
+        self.assertIn("not a site survey", evidence[0].limitation)
+
+    def test_fetch_topography_failure_returns_safe_evidence(self):
+        selection = selection_from_lat_lon(21.002, 70.245, radius_m=250)
+        with patch("src.topography.get_json", side_effect=TimeoutError("slow")):
+            topo, evidence = fetch_topography(selection)
+
+        self.assertEqual(topo, {})
+        self.assertEqual(evidence[0].confidence, "low")
+        self.assertIn("Do not infer slope", evidence[0].design_implication)
+
+
+if __name__ == "__main__":
+    unittest.main()