PyPI - gmaprium - Versions diffs - 0.1.0__py3-none-any.whl - Mend

gmaprium 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

gmaprium/__init__.py +21 -0
gmaprium/elements.py +692 -0
gmaprium/streamlit.py +40 -0
gmaprium/tiles.py +58 -0
gmaprium-0.1.0.dist-info/METADATA +183 -0
gmaprium-0.1.0.dist-info/RECORD +8 -0
gmaprium-0.1.0.dist-info/WHEEL +4 -0
gmaprium-0.1.0.dist-info/licenses/LICENSE +21 -0

gmaprium/__init__.py ADDED Viewed

@@ -0,0 +1,21 @@
+"""Folium-style Python helpers for Google Maps."""
+from .elements import Circle, GeoJson, GoogleMapsError, HeatMap, LayerControl, Map, Marker, Polygon, Polyline
+from .streamlit import st_google_map
+from .tiles import GoogleMapType, add_google_tiles, google_tiles_url
+__all__ = [
+    "Circle",
+    "GeoJson",
+    "GoogleMapType",
+    "GoogleMapsError",
+    "HeatMap",
+    "LayerControl",
+    "Map",
+    "Marker",
+    "Polygon",
+    "Polyline",
+    "add_google_tiles",
+    "google_tiles_url",
+    "st_google_map",
+]

gmaprium/elements.py ADDED Viewed

@@ -0,0 +1,692 @@
+"""Folium-style map elements for Google Maps output."""
+from __future__ import annotations
+import json
+import os
+from pathlib import Path
+from typing import Any, Iterable, Sequence
+Location = Sequence[float]
+_MAP_TYPES = {"roadmap", "satellite", "hybrid", "terrain"}
+_DEMO_MAP_ID = "DEMO_MAP_ID"
+class GoogleMapsError(RuntimeError):
+    """Raised when a map cannot be rendered with the supplied configuration."""
+class Element:
+    """Base class for objects that can be added to a map."""
+    def add_to(self, map_obj: "Map") -> "Element":
+        map_obj.add_child(self)
+        return self
+    def to_spec(self) -> dict[str, Any]:
+        raise NotImplementedError
+class Map:
+    """A Folium-style Google Maps HTML renderer."""
+    def __init__(
+        self,
+        location: Location,
+        zoom_start: int = 10,
+        *,
+        api_key: str | None = None,
+        map_type: str = "roadmap",
+        width: str | int = "100%",
+        height: str | int = "100%",
+        map_id: str | None = None,
+        options: dict[str, Any] | None = None,
+    ) -> None:
+        self.location = _location(location)
+        self.zoom_start = zoom_start
+        self.api_key = api_key
+        if map_type not in _MAP_TYPES:
+            supported = ", ".join(sorted(_MAP_TYPES))
+            raise ValueError(f"Unsupported map_type {map_type!r}. Expected one of: {supported}.")
+        self.map_type = map_type
+        self.width = _css_size(width)
+        self.height = _css_size(height)
+        self.map_id = map_id
+        self.options = options or {}
+        self.children: list[Element] = []
+        self._id = f"fgm_{id(self):x}"
+    def add_child(self, child: Element) -> Element:
+        self.children.append(child)
+        return child
+    def render_fragment(self) -> str:
+        api_key = self._resolve_api_key()
+        specs = [child.to_spec() for child in self.children]
+        needs_marker = any(spec["type"] == "marker" for spec in specs)
+        layer_control = any(spec["type"] == "layer_control" for spec in specs)
+        drawable_specs = [spec for spec in specs if spec["type"] != "layer_control"]
+        config = {
+            "center": {"lat": self.location[0], "lng": self.location[1]},
+            "zoom": self.zoom_start,
+            "mapTypeId": self.map_type,
+            **self.options,
+        }
+        if self.map_id or needs_marker:
+            config["mapId"] = self.map_id or _DEMO_MAP_ID
+        context = {
+            "api_key": api_key,
+            "callback": f"{self._id}_init",
+            "config": config,
+            "height": self.height,
+            "map_id": self._id,
+            "specs": drawable_specs,
+            "width": self.width,
+            "layer_control": layer_control,
+        }
+        return _render_fragment(context)
+    def render_html(self) -> str:
+        fragment = self.render_fragment()
+        return "\n".join(
+            [
+                "<!doctype html>",
+                '<html lang="en">',
+                "<head>",
+                '  <meta charset="utf-8">',
+                '  <meta name="viewport" content="width=device-width, initial-scale=1">',
+                "  <title>Google Map</title>",
+                "</head>",
+                "<body>",
+                fragment,
+                "</body>",
+                "</html>",
+            ]
+        )
+    def save(self, path: str | os.PathLike[str]) -> None:
+        Path(path).write_text(self.render_html(), encoding="utf-8")
+    def _repr_html_(self) -> str:
+        return self.render_fragment()
+    def _resolve_api_key(self) -> str:
+        api_key = self.api_key or os.environ.get("GOOGLE_MAPS_API_KEY")
+        if not api_key:
+            raise GoogleMapsError("Google Maps API key is required. Pass api_key=... or set GOOGLE_MAPS_API_KEY.")
+        return api_key
+class Marker(Element):
+    def __init__(
+        self,
+        location: Location,
+        *,
+        popup: str | None = None,
+        tooltip: str | None = None,
+        icon: str | None = None,
+        draggable: bool = False,
+        name: str | None = None,
+    ) -> None:
+        self.location = _location(location)
+        self.popup = popup
+        self.tooltip = tooltip
+        self.icon = icon
+        self.draggable = draggable
+        self.name = name
+    def to_spec(self) -> dict[str, Any]:
+        return {
+            "type": "marker",
+            "name": self.name,
+            "position": {"lat": self.location[0], "lng": self.location[1]},
+            "popup": self.popup,
+            "tooltip": self.tooltip,
+            "icon": self.icon,
+            "draggable": self.draggable,
+        }
+class Polyline(Element):
+    def __init__(
+        self,
+        locations: Iterable[Location],
+        *,
+        color: str = "#3388ff",
+        weight: int = 3,
+        opacity: float = 1.0,
+        name: str | None = None,
+    ) -> None:
+        self.locations = [_lat_lng(location) for location in locations]
+        self.color = color
+        self.weight = weight
+        self.opacity = opacity
+        self.name = name
+    def to_spec(self) -> dict[str, Any]:
+        return {
+            "type": "polyline",
+            "name": self.name,
+            "path": self.locations,
+            "options": {"strokeColor": self.color, "strokeWeight": self.weight, "strokeOpacity": self.opacity},
+        }
+class Polygon(Element):
+    def __init__(
+        self,
+        locations: Iterable[Location] | Iterable[Iterable[Location]],
+        *,
+        color: str = "#3388ff",
+        fill_color: str | None = None,
+        fill_opacity: float = 0.2,
+        weight: int = 3,
+        name: str | None = None,
+    ) -> None:
+        self.locations = _polygon_paths(locations)
+        self.color = color
+        self.fill_color = fill_color or color
+        self.fill_opacity = fill_opacity
+        self.weight = weight
+        self.name = name
+    def to_spec(self) -> dict[str, Any]:
+        return {
+            "type": "polygon",
+            "name": self.name,
+            "paths": self.locations,
+            "options": {
+                "strokeColor": self.color,
+                "strokeWeight": self.weight,
+                "fillColor": self.fill_color,
+                "fillOpacity": self.fill_opacity,
+            },
+        }
+class Circle(Element):
+    def __init__(
+        self,
+        location: Location,
+        radius: float,
+        *,
+        color: str = "#3388ff",
+        fill_color: str | None = None,
+        fill_opacity: float = 0.2,
+        weight: int = 3,
+        name: str | None = None,
+    ) -> None:
+        self.location = _location(location)
+        self.radius = radius
+        self.color = color
+        self.fill_color = fill_color or color
+        self.fill_opacity = fill_opacity
+        self.weight = weight
+        self.name = name
+    def to_spec(self) -> dict[str, Any]:
+        return {
+            "type": "circle",
+            "name": self.name,
+            "center": {"lat": self.location[0], "lng": self.location[1]},
+            "radius": self.radius,
+            "options": {
+                "strokeColor": self.color,
+                "strokeWeight": self.weight,
+                "fillColor": self.fill_color,
+                "fillOpacity": self.fill_opacity,
+            },
+        }
+class GeoJson(Element):
+    def __init__(self, data: Any, *, name: str | None = None, style_function: Any | None = None) -> None:
+        self.data = _geojson_data(data)
+        self.name = name
+        self.style_function = style_function
+    def to_spec(self) -> dict[str, Any]:
+        style = None
+        if self.style_function:
+            style = self.style_function(_sample_geojson_feature(self.data))
+        return {"type": "geojson", "name": self.name, "data": self.data, "style": style}
+class HeatMap(Element):
+    def __init__(
+        self,
+        data: Iterable[Any],
+        *,
+        name: str | None = None,
+        radius: int = 25,
+        blur: int = 15,
+        min_opacity: float = 0.05,
+        max_zoom: int | None = 18,
+        max_value: float = 1.0,
+        gradient: dict[float, str] | None = None,
+        opacity: float = 1.0,
+        intensity: float = 1.0,
+        threshold: float = 0.03,
+        scale_radius_with_zoom: bool = False,
+        min_radius: int = 6,
+        max_radius: int = 240,
+    ) -> None:
+        self.data = [_heatmap_point(point) for point in data]
+        self.name = name
+        self.radius = radius
+        self.blur = blur
+        self.min_opacity = min_opacity
+        self.max_zoom = max_zoom
+        self.max_value = max_value
+        self.gradient = gradient or {0.4: "blue", 0.6: "cyan", 0.7: "lime", 0.8: "yellow", 1.0: "red"}
+        self.opacity = opacity
+        self.intensity = intensity
+        self.threshold = threshold
+        self.scale_radius_with_zoom = scale_radius_with_zoom
+        self.min_radius = min_radius
+        self.max_radius = max_radius
+    def to_spec(self) -> dict[str, Any]:
+        return {
+            "type": "heatmap",
+            "name": self.name,
+            "data": self.data,
+            "options": {
+                "radiusPixels": self.radius,
+                "blurPixels": self.blur,
+                "minOpacity": self.min_opacity,
+                "maxZoom": self.max_zoom,
+                "max": self.max_value,
+                "gradient": self.gradient,
+                "opacity": self.opacity,
+                "intensity": self.intensity,
+                "threshold": self.threshold,
+                "scaleRadiusWithZoom": self.scale_radius_with_zoom,
+                "minRadiusPixels": self.min_radius,
+                "maxRadiusPixels": self.max_radius,
+            },
+        }
+class LayerControl(Element):
+    def to_spec(self) -> dict[str, Any]:
+        return {"type": "layer_control"}
+def _location(value: Location) -> tuple[float, float]:
+    if len(value) != 2:
+        raise ValueError("Location must be a [lat, lng] pair.")
+    return (float(value[0]), float(value[1]))
+def _lat_lng(value: Location) -> dict[str, float]:
+    lat, lng = _location(value)
+    return {"lat": lat, "lng": lng}
+def _css_size(value: str | int) -> str:
+    if isinstance(value, int):
+        return f"{value}px"
+    return value
+def _polygon_paths(locations: Iterable[Location] | Iterable[Iterable[Location]]) -> list[Any]:
+    items = list(locations)
+    if not items:
+        return []
+    first = items[0]
+    if _looks_like_location(first):
+        return [_lat_lng(item) for item in items]  # type: ignore[arg-type]
+    return [[_lat_lng(point) for point in path] for path in items]  # type: ignore[arg-type]
+def _looks_like_location(value: Any) -> bool:
+    return isinstance(value, Sequence) and len(value) == 2 and all(isinstance(item, (int, float)) for item in value)
+def _geojson_data(data: Any) -> dict[str, Any]:
+    if isinstance(data, (str, os.PathLike)):
+        return json.loads(Path(data).read_text(encoding="utf-8"))
+    if isinstance(data, dict):
+        return data
+    if hasattr(data, "__geo_interface__"):
+        return data.__geo_interface__
+    if hasattr(data, "to_json"):
+        return json.loads(data.to_json())
+    raise TypeError("GeoJson data must be a dict, path, __geo_interface__ object, or object with to_json().")
+def _sample_geojson_feature(data: dict[str, Any]) -> dict[str, Any]:
+    if data.get("type") == "FeatureCollection" and data.get("features"):
+        return data["features"][0]
+    if data.get("type") == "Feature":
+        return data
+    return {"type": "Feature", "properties": {}, "geometry": None}
+def _heatmap_point(point: Any) -> dict[str, Any]:
+    if isinstance(point, dict):
+        location = point.get("location")
+        if location is None:
+            location = [point.get("lat"), point.get("lng")]
+        lat, lng = _location(location)
+        return {"position": [lng, lat], "weight": float(point.get("weight", 1))}
+    if isinstance(point, Sequence) and len(point) in {2, 3}:
+        lat, lng = _location(point[:2])
+        weight = float(point[2]) if len(point) == 3 else 1.0
+        return {"position": [lng, lat], "weight": weight}
+    raise TypeError("HeatMap points must be [lat, lng], [lat, lng, weight], or {'location': [lat, lng], 'weight': n}.")
+def _json(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+def _render_fragment(context: dict[str, Any]) -> str:
+    specs_json = _json(context["specs"])
+    config_json = _json(context["config"])
+    api_key = _json(context["api_key"])
+    map_id = context["map_id"]
+    callback = context["callback"]
+    control_style = (
+        f"<style>#{map_id}_layers{{background:#fff;"
+        "border:1px solid #dadce0;border-radius:4px;padding:8px;font:13px Arial,sans-serif;"
+        "box-shadow:0 1px 4px rgba(0,0,0,.2);margin:10px}"
+        f"#{map_id}_layers label{{display:block;white-space:nowrap;margin:4px 0}}</style>\n"
+        if context["layer_control"]
+        else ""
+    )
+    control_div = f'<div id="{map_id}_layers" hidden></div>' if context["layer_control"] else ""
+    return f"""<div id="{map_id}_wrap" style="position:relative;width:{context['width']};height:{context['height']};">
+  <div id="{map_id}" style="width:100%;height:100%;"></div>
+  {control_div}
+</div>
+{control_style}<script>
+function {callback}_loadScript(src, test) {{
+  if (test()) return Promise.resolve();
+  return new Promise((resolve, reject) => {{
+    const existing = Array.from(document.scripts).find(script => script.dataset.fgmSrc === src);
+    if (existing) {{
+      existing.addEventListener("load", resolve, {{ once: true }});
+      existing.addEventListener("error", reject, {{ once: true }});
+      if (test()) resolve();
+      return;
+    }}
+    const script = document.createElement("script");
+    script.async = true;
+    script.dataset.fgmSrc = src;
+    script.src = src;
+    script.addEventListener("load", resolve, {{ once: true }});
+    script.addEventListener("error", reject, {{ once: true }});
+    document.head.appendChild(script);
+  }});
+}}
+window.{callback} = async function() {{
+  const specs = {specs_json};
+  const config = {config_json};
+  const namedLayers = [];
+  const {{ Map, InfoWindow, Polyline, Polygon, Circle }} = await google.maps.importLibrary("maps");
+  const {{ AdvancedMarkerElement }} = await google.maps.importLibrary("marker");
+  const map = new Map(document.getElementById("{map_id}"), config);
+  const panorama = map.getStreetView();
+  let streetViewVisible = panorama.getVisible();
+  function track(name, layer, setVisible, options = {{}}) {{
+    if (!name) return;
+    const entry = {{
+      name,
+      layer,
+      setVisible,
+      hideInStreetView: Boolean(options.hideInStreetView),
+      layerVisible: true,
+      applyVisibility() {{
+        setVisible(this.layerVisible && !(this.hideInStreetView && streetViewVisible));
+      }}
+    }};
+    namedLayers.push(entry);
+  }}
+  for (const spec of specs) {{
+    if (spec.type === "marker") {{
+      const markerOptions = {{
+        map,
+        position: spec.position,
+        title: spec.tooltip || undefined,
+        gmpClickable: Boolean(spec.popup),
+        gmpDraggable: spec.draggable || false
+      }};
+      if (spec.icon) {{
+        const img = document.createElement("img");
+        img.src = spec.icon;
+        markerOptions.content = img;
+      }}
+      const marker = new AdvancedMarkerElement(markerOptions);
+      if (spec.popup) {{
+        const info = new InfoWindow({{ content: spec.popup }});
+        marker.addListener("click", () => info.open({{ anchor: marker, map }}));
+      }}
+      track(spec.name, marker, visible => marker.map = visible ? map : null);
+    }} else if (spec.type === "polyline") {{
+      const layer = new Polyline({{ map, path: spec.path, ...spec.options }});
+      track(spec.name, layer, visible => layer.setMap(visible ? map : null));
+    }} else if (spec.type === "polygon") {{
+      const layer = new Polygon({{ map, paths: spec.paths, ...spec.options }});
+      track(spec.name, layer, visible => layer.setMap(visible ? map : null));
+    }} else if (spec.type === "circle") {{
+      const layer = new Circle({{ map, center: spec.center, radius: spec.radius, ...spec.options }});
+      track(spec.name, layer, visible => layer.setMap(visible ? map : null));
+    }} else if (spec.type === "geojson") {{
+      const layer = new google.maps.Data({{ map }});
+      layer.addGeoJson(spec.data);
+      if (spec.style) layer.setStyle(spec.style);
+      track(spec.name, layer, visible => layer.setMap(visible ? map : null));
+    }} else if (spec.type === "heatmap") {{
+      class CanvasHeatmapOverlay extends google.maps.OverlayView {{
+        constructor(data, options, baseZoom) {{
+          super();
+          this.data = data;
+          this.options = options;
+          this.baseZoom = baseZoom;
+          this.canvas = null;
+          this.listeners = [];
+          this.circle = null;
+          this.circleRadius = null;
+          this.circleBlur = null;
+          this.gradientPixels = null;
+          this.gradientKey = null;
+        }}
+        onAdd() {{
+          this.canvas = document.createElement("canvas");
+          this.canvas.style.position = "absolute";
+          this.canvas.style.inset = "0";
+          this.canvas.style.zIndex = "5";
+          this.canvas.style.pointerEvents = "none";
+          this.canvas.dataset.fgmHeatmap = "true";
+          this.getMap().getDiv().appendChild(this.canvas);
+          this.listeners.push(google.maps.event.addListener(this.getMap(), "idle", () => this.draw()));
+          this.listeners.push(google.maps.event.addListener(this.getMap(), "bounds_changed", () => this.draw()));
+          this.listeners.push(google.maps.event.addListener(this.getMap(), "zoom_changed", () => this.draw()));
+        }}
+        draw() {{
+          if (!this.canvas) return;
+          const projection = this.getProjection();
+          const mapDiv = this.getMap().getDiv();
+          if (!projection || !mapDiv) return;
+          const width = Math.max(1, mapDiv.clientWidth);
+          const height = Math.max(1, mapDiv.clientHeight);
+          this.canvas.width = width;
+          this.canvas.height = height;
+          this.canvas.style.width = width + "px";
+          this.canvas.style.height = height + "px";
+          const ctx = this.canvas.getContext("2d", {{ willReadFrequently: true }});
+          ctx.clearRect(0, 0, width, height);
+          const radius = this.options.radiusPixels || 25;
+          const blur = this.options.blurPixels === undefined ? 15 : this.options.blurPixels;
+          const drawRadius = radius + blur;
+          const circle = this.getCircle(radius, blur);
+          const zoom = this.getMap().getZoom() ?? this.baseZoom;
+          const maxZoom = this.options.maxZoom ?? 18;
+          const zoomIntensity = 1 / Math.pow(2, Math.max(0, Math.min(maxZoom - zoom, 12)));
+          const maxValue = this.options.max || 1;
+          const minOpacity = this.options.minOpacity ?? 0.05;
+          const bounds = {{
+            minX: -drawRadius,
+            minY: -drawRadius,
+            maxX: width + drawRadius,
+            maxY: height + drawRadius
+          }};
+          const cellSize = drawRadius / 2;
+          const grid = [];
+          for (const point of this.data) {{
+            const lng = point.position[0];
+            const lat = point.position[1];
+            const pixel = projection.fromLatLngToContainerPixel(new google.maps.LatLng(lat, lng));
+            if (!pixel) continue;
+            if (pixel.x < bounds.minX || pixel.x > bounds.maxX || pixel.y < bounds.minY || pixel.y > bounds.maxY) continue;
+            const x = Math.floor(pixel.x / cellSize) + 2;
+            const y = Math.floor(pixel.y / cellSize) + 2;
+            const value = (point.weight === undefined ? 1 : point.weight) * zoomIntensity;
+            grid[y] = grid[y] || [];
+            const cell = grid[y][x];
+            if (!cell) {{
+              grid[y][x] = [pixel.x, pixel.y, value];
+            }} else {{
+              cell[0] = (cell[0] * cell[2] + pixel.x * value) / (cell[2] + value);
+              cell[1] = (cell[1] * cell[2] + pixel.y * value) / (cell[2] + value);
+              cell[2] += value;
+            }}
+          }}
+          for (const row of grid) {{
+            if (!row) continue;
+            for (const cell of row) {{
+              if (!cell) continue;
+              ctx.globalAlpha = Math.min(Math.max(cell[2] / maxValue, minOpacity), 1);
+              ctx.drawImage(circle, Math.round(cell[0]) - drawRadius, Math.round(cell[1]) - drawRadius);
+            }}
+          }}
+          ctx.globalAlpha = 1;
+          const image = ctx.getImageData(0, 0, this.canvas.width, this.canvas.height);
+          this.colorize(image.data, this.getGradient());
+          ctx.putImageData(image, 0, 0);
+        }}
+        getCircle(radius, blur) {{
+          if (this.circle && this.circleRadius === radius && this.circleBlur === blur) return this.circle;
+          const drawRadius = radius + blur;
+          const circle = document.createElement("canvas");
+          const ctx = circle.getContext("2d");
+          circle.width = circle.height = drawRadius * 2;
+          ctx.shadowOffsetX = ctx.shadowOffsetY = drawRadius * 2;
+          ctx.shadowBlur = blur;
+          ctx.shadowColor = "black";
+          ctx.beginPath();
+          ctx.arc(-drawRadius, -drawRadius, radius, 0, Math.PI * 2, true);
+          ctx.closePath();
+          ctx.fill();
+          this.circle = circle;
+          this.circleRadius = radius;
+          this.circleBlur = blur;
+          return circle;
+        }}
+        getGradient() {{
+          const gradient = this.options.gradient || {{ 0.4: "blue", 0.6: "cyan", 0.7: "lime", 0.8: "yellow", 1.0: "red" }};
+          const key = JSON.stringify(gradient);
+          if (this.gradientPixels && this.gradientKey === key) return this.gradientPixels;
+          const canvas = document.createElement("canvas");
+          const ctx = canvas.getContext("2d", {{ willReadFrequently: true }});
+          const linearGradient = ctx.createLinearGradient(0, 0, 0, 256);
+          canvas.width = 1;
+          canvas.height = 256;
+          for (const stop in gradient) {{
+            linearGradient.addColorStop(Number(stop), gradient[stop]);
+          }}
+          ctx.fillStyle = linearGradient;
+          ctx.fillRect(0, 0, 1, 256);
+          this.gradientPixels = ctx.getImageData(0, 0, 1, 256).data;
+          this.gradientKey = key;
+          return this.gradientPixels;
+        }}
+        colorize(pixels, gradient) {{
+          for (let i = 0; i < pixels.length; i += 4) {{
+            const j = pixels[i + 3] * 4;
+            if (j) {{
+              pixels[i] = gradient[j];
+              pixels[i + 1] = gradient[j + 1];
+              pixels[i + 2] = gradient[j + 2];
+            }}
+          }}
+        }}
+        onRemove() {{
+          for (const listener of this.listeners) {{
+            google.maps.event.removeListener(listener);
+          }}
+          this.listeners = [];
+          if (this.canvas) {{
+            this.canvas.remove();
+            this.canvas = null;
+          }}
+        }}
+      }}
+      const layer = new CanvasHeatmapOverlay(spec.data, spec.options, config.zoom);
+      layer.setMap(map);
+      track(spec.name, layer, visible => layer.setMap(visible ? map : null), {{ hideInStreetView: true }});
+    }}
+  }}
+  panorama.addListener("visible_changed", () => {{
+    streetViewVisible = panorama.getVisible();
+    for (const entry of namedLayers) {{
+      entry.applyVisibility();
+    }}
+  }});
+  const control = document.getElementById("{map_id}_layers");
+  if (control && namedLayers.length) {{
+    control.hidden = false;
+    for (const entry of namedLayers) {{
+      const label = document.createElement("label");
+      const checkbox = document.createElement("input");
+      checkbox.type = "checkbox";
+      checkbox.checked = true;
+      checkbox.addEventListener("change", () => {{
+        entry.layerVisible = checkbox.checked;
+        entry.applyVisibility();
+      }});
+      label.appendChild(checkbox);
+      label.appendChild(document.createTextNode(" " + entry.name));
+      control.appendChild(label);
+    }}
+    map.controls[google.maps.ControlPosition.TOP_RIGHT].push(control);
+  }}
+}};
+</script>
+<script>
+(function() {{
+  if (window.google && google.maps && google.maps.importLibrary) {{
+    window.{callback}();
+    return;
+  }}
+  if (document.querySelector("script[data-fgm-google='{callback}']")) return;
+  const script = document.createElement("script");
+  script.async = true;
+  script.dataset.fgmGoogle = "{callback}";
+  script.src = "https://maps.googleapis.com/maps/api/js?key=" + encodeURIComponent({api_key}) + "&loading=async&callback={callback}";
+  document.head.appendChild(script);
+}})();
+</script>"""

gmaprium/streamlit.py ADDED Viewed

@@ -0,0 +1,40 @@
+"""Streamlit integration helpers."""
+from __future__ import annotations
+from typing import Any
+from .elements import Map
+def st_google_map(
+    map_obj: Map,
+    *,
+    height: int | None = None,
+    width: int | None = None,
+    scrolling: bool = False,
+    **kwargs: Any,
+) -> Any:
+    """Render a gmaprium map in Streamlit."""
+    try:
+        import streamlit.components.v1 as components
+    except ImportError as exc:
+        raise RuntimeError('streamlit is required. Install with: pip install "gmaprium[streamlit]"') from exc
+    component_height = height or _height_to_pixels(map_obj.height)
+    return components.html(
+        map_obj.render_html(),
+        height=component_height,
+        width=width,
+        scrolling=scrolling,
+        **kwargs,
+    )
+def _height_to_pixels(value: str) -> int:
+    if value.endswith("px"):
+        try:
+            return int(value[:-2])
+        except ValueError:
+            return 500
+    return 500

gmaprium/tiles.py ADDED Viewed

@@ -0,0 +1,58 @@
+"""Utilities for adding Google Maps tile layers to Folium maps."""
+from __future__ import annotations
+from typing import Literal
+from urllib.parse import urlencode
+GoogleMapType = Literal["roadmap", "satellite", "terrain", "hybrid"]
+_GOOGLE_TILE_ENDPOINT = "https://mt1.google.com/vt/lyrs={layer}&x={x}&y={y}&z={z}"
+_MAP_TYPE_TO_LAYER: dict[GoogleMapType, str] = {
+    "roadmap": "m",
+    "satellite": "s",
+    "terrain": "p",
+    "hybrid": "y",
+}
+def google_tiles_url(map_type: GoogleMapType = "roadmap", api_key: str | None = None) -> str:
+    """Return a Google Maps tile URL template for Folium."""
+    layer = _MAP_TYPE_TO_LAYER.get(map_type)
+    if layer is None:
+        supported = ", ".join(sorted(_MAP_TYPE_TO_LAYER))
+        raise ValueError(f"Unsupported map_type {map_type!r}. Expected one of: {supported}.")
+    url = _GOOGLE_TILE_ENDPOINT.format(layer=layer, x="{x}", y="{y}", z="{z}")
+    if api_key:
+        url = f"{url}&{urlencode({'key': api_key})}"
+    return url
+def add_google_tiles(
+    map_obj: object,
+    *,
+    api_key: str | None = None,
+    map_type: GoogleMapType = "roadmap",
+    name: str | None = None,
+    attr: str = "Google",
+    overlay: bool = False,
+    control: bool = True,
+    show: bool = True,
+) -> object:
+    """Add a Google Maps tile layer to a Folium map and return the layer."""
+    try:
+        import folium
+    except ImportError as exc:  # pragma: no cover - dependency metadata should install folium
+        raise RuntimeError("folium is required to add Google Maps tiles.") from exc
+    layer = folium.TileLayer(
+        tiles=google_tiles_url(map_type=map_type, api_key=api_key),
+        name=name or f"Google {map_type.title()}",
+        attr=attr,
+        overlay=overlay,
+        control=control,
+        show=show,
+    )
+    layer.add_to(map_obj)
+    return layer

gmaprium-0.1.0.dist-info/METADATA ADDED Viewed

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: gmaprium
+Version: 0.1.0
+Summary: Folium-style Python helpers for rendering Google Maps.
+Project-URL: Homepage, https://github.com/KentaroAOKI/gmaprium
+Project-URL: Repository, https://github.com/KentaroAOKI/gmaprium
+Project-URL: Issues, https://github.com/KentaroAOKI/gmaprium/issues
+Author: Kentaro
+License: MIT
+License-File: LICENSE
+Keywords: folium,geojson,google-maps,heatmap,maps,streamlit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: jinja2>=3.1
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: twine>=5; extra == 'dev'
+Provides-Extra: streamlit
+Requires-Dist: streamlit>=1.30; extra == 'streamlit'
+Description-Content-Type: text/markdown
+# gmaprium
+Folium-style Python helpers for rendering Google Maps HTML.
+gmaprium can be used to create standalone HTML maps, display maps in Jupyter Notebook, add Google tile layers to existing Folium maps, and embed maps in Streamlit apps.
+## Installation
+```bash
+pip install gmaprium
+```
+## Usage
+```python
+from gmaprium import GeoJson, HeatMap, LayerControl, Map, Marker, Polygon
+m = Map(
+    location=[35.6812, 139.7671],
+    zoom_start=12,
+    api_key="YOUR_GOOGLE_MAPS_API_KEY",
+    map_type="roadmap",
+    height="500px",
+)
+Marker([35.6812, 139.7671], popup="Tokyo Station", tooltip="Tokyo", name="Stations").add_to(m)
+Polygon(
+    [[35.70, 139.70], [35.70, 139.82], [35.62, 139.82], [35.62, 139.70]],
+    name="Area",
+).add_to(m)
+HeatMap([[35.6812, 139.7671, 2], [35.6895, 139.6917, 1]], name="Heat").add_to(m)
+LayerControl().add_to(m)
+# Full HTML document.
+m.save("map.html")
+# Embeddable HTML fragment for web apps.
+html = m.render_fragment()
+```
+You can also pass the API key with the `GOOGLE_MAPS_API_KEY` environment variable.
+Markers use Google's `AdvancedMarkerElement`. If you add markers without passing `map_id=...`, the renderer uses Google's `DEMO_MAP_ID` for local testing.
+## Supported Elements
+- `Map`
+- `Marker`
+- `Polyline`
+- `Polygon`
+- `Circle`
+- `GeoJson`
+- `HeatMap`
+- `LayerControl`
+`GeoJson` accepts GeoJSON dictionaries, JSON file paths, objects with `__geo_interface__`, and GeoPandas-like objects with `to_json()`.
+`HeatMap` uses a canvas overlay instead of Google's deprecated JavaScript `HeatmapLayer`.
+It ports the Leaflet.heat/simpleheat rendering model, including `radius`, `blur`, `min_opacity`, `max_zoom`, `max_value`, and `gradient`.
+The defaults match Leaflet.heat/simpleheat on a typical OSM map: `radius=25`, `blur=15`, `min_opacity=0.05`, `max_zoom=18`, `max_value=1.0`, and the blue-cyan-lime-yellow-red gradient.
+Lower zoom levels are intentionally faded by Leaflet.heat's `max_zoom - zoom` intensity scale. Set `max_zoom` closer to your initial zoom if the heat fades too quickly.
+The legacy `google_tiles_url()` and `add_google_tiles()` helpers are still available for projects that want to add Google tile URLs to an existing Folium map.
+## Notebook
+In Jupyter Notebook, display the map by returning the `Map` object as the last expression in a cell.
+```python
+import os
+from gmaprium import HeatMap, LayerControl, Map, Marker
+os.environ["GOOGLE_MAPS_API_KEY"] = "your-api-key"
+m = Map(location=[35.6812, 139.7671], zoom_start=12, height="500px")
+Marker([35.6812, 139.7671], popup="Tokyo Station", name="Markers").add_to(m)
+HeatMap([[35.6812, 139.7671, 1.0]], name="Heat", max_zoom=14).add_to(m)
+LayerControl().add_to(m)
+m
+```
+You can also display explicitly:
+```python
+from IPython.display import HTML, display
+display(HTML(m.render_fragment()))
+```
+The notebook example is available at `examples/example.ipynb`.
+## Folium Extension
+If you already use Folium, add Google tile layers to a `folium.Map` with `add_google_tiles()`.
+```python
+import folium
+from gmaprium import add_google_tiles
+m = folium.Map(location=[35.6812, 139.7671], zoom_start=12, tiles=None)
+add_google_tiles(m, api_key="your-api-key", map_type="roadmap", name="Google Roadmap")
+add_google_tiles(m, api_key="your-api-key", map_type="satellite", name="Google Satellite", show=False)
+folium.LayerControl().add_to(m)
+m.save("folium_google_tiles.html")
+```
+This Folium extension only adds Google tile layers. It does not enable the Google Maps JavaScript API renderer or gmaprium's `HeatMap`.
+The Folium example is available at `examples/folium_extension.py`.
+## Streamlit
+Use `st_google_map()` to render a `gmaprium.Map` inside a Streamlit app.
+```python
+import os
+import streamlit as st
+from gmaprium import Map, Marker, st_google_map
+api_key = os.environ["GOOGLE_MAPS_API_KEY"]
+m = Map(location=[35.6812, 139.7671], zoom_start=12, api_key=api_key, height="600px")
+Marker([35.6812, 139.7671], popup="Tokyo Station").add_to(m)
+st_google_map(m)
+```
+Install the optional dependency and run the example app:
+```bash
+python -m pip install -e ".[dev,streamlit]"
+export GOOGLE_MAPS_API_KEY="your-api-key"
+streamlit run examples/streamlit_app.py
+```
+The Streamlit example is available at `examples/streamlit_app.py`.
+## Development
+```bash
+python -m pip install -e ".[dev]"
+pytest
+```

gmaprium-0.1.0.dist-info/RECORD ADDED Viewed

@@ -0,0 +1,8 @@
+gmaprium/__init__.py,sha256=RsseaUbwHy638v9s4Ro84JeF4IWM4oDHyTh5eBK66bg,516
+gmaprium/elements.py,sha256=6LFCe3suTBGgVbwIWwI20wp2nbXdwKpzHQjcW1_7ZOg,24794
+gmaprium/streamlit.py,sha256=rd-RhUXjBqBPy5K8SsvkiP9lrgzPJqUT-7i5sc13zIw,958
+gmaprium/tiles.py,sha256=1pEhpsm3_kBxnCT9U3NkVHzecTFM8vBMBrO2KL7PH6I,1835
+gmaprium-0.1.0.dist-info/METADATA,sha256=PyZvyPnuidbizmeTvfkbxlt-kjiF0-wqCqvu5ZEM1yA,5753
+gmaprium-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+gmaprium-0.1.0.dist-info/licenses/LICENSE,sha256=3I50LCak8rl9pvb4R1Ij_06bwTDMJ2d7HHVRiCNKuyE,1069
+gmaprium-0.1.0.dist-info/RECORD,,

gmaprium-0.1.0.dist-info/WHEEL ADDED Viewed

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

gmaprium-0.1.0.dist-info/licenses/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2026 Kentaro Aoki
+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.