WIP: Introduce Marker and MarkerContent

- MarkerContent is an abstract method. It can be either a Pin or Image
- Marker object comprises of MarkerContent
- Add unit tests
- I am bothered by the use of `eval` method for the content

Author: argysamo

examples/example_2.py

@@ -57,9 +57,7 @@ def map_created_in_view():
     )
 
     #  print(get_address(api, 22.4761596, 88.4149326))
-    return render_template(
-        "example_2.html", dmap=dmap, gmap=gmap, wmap=wmap, key=api
-    )
+    return render_template("example_2.html", dmap=dmap, gmap=gmap, wmap=wmap, key=api)
 
 
 if __name__ == "__main__":

examples/simple.py

@@ -1,18 +1,12 @@
 from flask import Flask, render_template
 
 from flask_googlemaps import GoogleMaps, Map
+from flask_googlemaps.image import Image
 from flask_googlemaps.pin import Pin
 
 app = Flask(__name__)
 GoogleMaps(app)
 
-red = Pin(border_color="", glyph_color="",
-          background="",
-          glyph="https://developers.google.com/maps/documentation/javascript/examples/full/images/beachflag.png")
-blue = Pin(border_color="blue", glyph_color="",
-           background="black",
-           glyph="https://developers.google.com/maps/documentation/javascript/examples/full/images/beachflag.png")
-
 
 @app.route("/")
 def map_created_in_view():
@@ -21,10 +15,20 @@ def map_created_in_view():
         varname="gmap",
         lat=37.4419,
         lng=-122.1419,
-        markers={
-            red: [(37.4419, -122.1419),],
-            blue: [(37.4300, -122.1400, "Hello World")],
-        },
+        markers=[
+            {
+                "latitude": 37.4419,
+                "longitude": -122.1419,
+                "label": "1",
+                # 'content': Pin(border_color="blue", background="blue")
+                "content": Pin(border_color="blue", background="blue"),
+            },
+            {
+                "latitude": 37.4519,
+                "longitude": -122.1519,
+                "content": Pin(border_color="blue", background="blue"),
+            },
+        ],
         style="height:400px;width:600px;margin:0;",
     )
 

flask_googlemaps/__init__.py

@@ -1,16 +1,16 @@
 """FlaskGoogleMaps - Google Maps Extension for Flask"""
 
-__version__ = "0.4.2"
+__version__ = "0.5.0"
 
 from json import dumps
 from typing import Optional, Dict, Any, List, Union, Tuple, Text
+
 import requests
 from flask import Blueprint, g, render_template
 from markupsafe import Markup
 
-from flask_googlemaps.pin import Pin
+from flask_googlemaps.marker import Marker
 
-DEFAULT_PIN = Pin(border_color="", glyph_color="", background="")
 DEFAULT_CLUSTER_IMAGE_PATH = "static/images/m"
 
 
@@ -28,7 +28,8 @@ def __init__(
         cls="map",  # type: str
         language="en",  # type: str
         region="US",  # type: str
-        rectangles=None,  # type: Optional[List[Union[List, Tuple, Tuple[Tuple], Dict]]]
+        rectangles=None,
+        # type: Optional[List[Union[List, Tuple, Tuple[Tuple], Dict]]]
         circles=None,  # type: Optional[List[Union[List, Tuple, Dict]]]
         polylines=None,  # type: Optional[List[Union[List, Tuple, Dict]]]
         polygons=None,  # type: Optional[List[Union[List, Tuple, Dict]]]
@@ -65,12 +66,11 @@ def __init__(
         self.language = language
         self.region = region
         self.varname = varname
-        self.center = self.verify_lat_lng_coordinates(lat, lng)
+        self.center = Marker.verify_latitude(lat), Marker.verify_longitude(lng)
         self.zoom = zoom
         self.maptype = maptype
-        self.markers = []  # type: List[Any]
+        self.markers = Marker.from_list(markers)  # type: List[Marker]
         self.map_ids = map_ids
-        self.build_markers(markers)
         self.rectangles = []  # type: List[Any]
         self.build_rectangles(rectangles)
         self.circles = []  # type: List[Any]
@@ -107,50 +107,6 @@ def __init__(
         self.heatmap_data = []
         self.build_heatmap(heatmap_data, heatmap_layer)
 
-    def build_markers(self, markers):
-        # type: (Optional[Union[Dict, List, Tuple]]) -> None
-        if not markers:
-            return
-        if not isinstance(markers, (dict, list, tuple)):
-            raise AttributeError("markers accepts only dict, list and tuple")
-
-        if isinstance(markers, dict):
-            for pin, marker_list in markers.items():
-                for marker in marker_list:
-                    marker_dict = self.build_marker_dict(marker, pin=pin)
-                    self.add_marker(**marker_dict)
-        else:
-            for marker in markers:
-                if isinstance(marker, dict):
-                    self.add_marker(**marker)
-                elif isinstance(marker, (tuple, list)):
-                    marker_dict = self.build_marker_dict(marker)
-                    self.add_marker(**marker_dict)
-
-    def build_marker_dict(self, marker, pin=None):
-        # type: (Union[List, Tuple], Optional[Pin]) -> Dict
-        marker_dict = {
-            "lat": marker[0],
-            "lng": marker[1],
-            "pin": pin or DEFAULT_PIN,
-        }
-        if len(marker) > 2:
-            marker_dict["infobox"] = marker[2]
-        if len(marker) > 3:
-            marker_dict["pin"] = marker[3]
-        return marker_dict
-
-    def add_marker(self, lat=None, lng=None, **kwargs):
-        # type: (Optional[float], Optional[float], **Any) -> None
-        if lat is not None:
-            kwargs["lat"] = lat
-        if lng is not None:
-            kwargs["lng"] = lng
-        if "lat" not in kwargs or "lng" not in kwargs:
-            raise AttributeError("lat and lng required")
-
-        self.markers.append(kwargs)
-
     def build_rectangles(self, rectangles):
         # type: (Optional[List[Union[List, Tuple, Tuple[Tuple], Dict]]]) -> None
         """Process data to construct rectangles
@@ -805,24 +761,10 @@ def as_json(self):
 
         return json_dict
 
-    def verify_lat_lng_coordinates(self, lat, lng):
-        if not (90 >= lat >= -90):
-            raise AttributeError(
-                "Latitude must be between -90 and 90 degrees inclusive."
-            )
-        if not (180 >= lng >= -180):
-            raise AttributeError(
-                "Longitude must be between -180 and 180 degrees inclusive."
-            )
-
-        return (lat, lng)
-
     @property
     def js(self):
         # type: () -> Markup
-        return Markup(
-            self.render("googlemaps/gmapjs.html", gmap=self, DEFAULT_PIN=DEFAULT_PIN)
-        )
+        return Markup(self.render("googlemaps/gmapjs.html", gmap=self, DEFAULT_PIN=""))
 
     @property
     def html(self):

flask_googlemaps/image.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+
+from flask_googlemaps.marker_content import MarkerContent
+
+
+@dataclass
+class Image(MarkerContent):
+    url: str
+
+    def content(self) -> str:
+        return self.name
+
+    def dom_element(self) -> str:
+        return (
+            f"const {self.name} = document.createElement('img');\n"
+            f"{self.name}.src = '{self.url}';"
+        )

flask_googlemaps/marker.py

@@ -0,0 +1,70 @@
+from typing import Optional, List, Any, Dict
+
+from flask_googlemaps.marker_content import MarkerContent
+from flask_googlemaps.pin import Pin
+
+DEFAULT_PIN = Pin()
+
+
+# from json import JSONEncoder
+#
+#
+# def wrapped_default(self, obj):
+#     return getattr(obj.__class__, "__json__", wrapped_default.default)(obj)
+#
+#
+# wrapped_default.default = JSONEncoder().default
+#
+# # apply the patch
+# JSONEncoder.original_default = JSONEncoder.default
+# JSONEncoder.default = wrapped_default
+
+
+class Marker(dict):
+
+    def __init__(
+        self,
+        latitude: float,
+        longitude: float,
+        infobox: Optional[str] = None,
+        content: Optional[MarkerContent] = None,
+        label: Optional[str] = None,
+    ):
+        self.latitude = Marker.verify_latitude(latitude)
+        self.longitude = Marker.verify_longitude(longitude)
+        self.infobox = infobox
+        self.marker_icon = content
+        self.content = content.content()
+        self.dom_element = content.dom_element()
+        self.label = label
+
+        dict.__init__(
+            self,
+            {
+                "latitude": self.latitude,
+                "longitude": self.longitude,
+                "infobox": self.infobox,
+                "content": self.content,
+                "id": self.marker_icon.name,
+            },
+        )
+
+    @staticmethod
+    def verify_latitude(latitude: float) -> Optional[float]:
+        if not (90 >= latitude >= -90):
+            raise AttributeError(
+                "Latitude must be between -90 and 90 degrees inclusive."
+            )
+        return latitude
+
+    @staticmethod
+    def verify_longitude(longitude: float) -> Optional[float]:
+        if not (180 >= longitude >= -180):
+            raise AttributeError(
+                "Longitude must be between -180 and 180 degrees inclusive."
+            )
+        return longitude
+
+    @staticmethod
+    def from_list(markers: List[Dict[str, Any]]) -> List["Marker"]:
+        return list(map(lambda marker: Marker(**marker), markers))

flask_googlemaps/marker_content.py

@@ -0,0 +1,18 @@
+import uuid
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass
+class MarkerContent(ABC):
+
+    def __post_init__(self):
+        self.name = f"var_{str(uuid.uuid1())[0:8]}"
+
+    @abstractmethod
+    def content(self) -> str:
+        pass
+
+    @abstractmethod
+    def dom_element(self) -> str:
+        pass

flask_googlemaps/pin.py

@@ -1,13 +1,40 @@
-import uuid
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Optional
 
+from flask_googlemaps.marker_content import MarkerContent
 
-@dataclass(frozen=True)
-class Pin:
-    border_color: str
-    glyph_color: str
-    background: str
-    glyph: Optional[str] = None
-    uuid: Optional[str] = field(default_factory=lambda: f"_{str(uuid.uuid1())[0:8]}")
+
+@dataclass
+class Pin(MarkerContent):
+
+    def __post_init__(self):
+        MarkerContent.__post_init__(self)
+        self.dom = []
+        if self.glyph_color:
+            self.dom.append(f"\tglyphColor: '{self.glyph_color}',")
+        if self.background:
+            self.dom.append(f"\tbackground: '{self.background}',")
+        if self.border_color:
+            self.dom.append(f"\tborderColor: '{self.border_color}',")
+        if self.glyph:
+            self.dom.append(f"\tglyph: '{self.glyph}',")
+        if self.dom:
+            self.dom.insert(0, f"const {self.name} = new PinElement({{")
+            self.dom.append("\t\t});\n")
+
+    def dom_element(self) -> Optional[str]:
+
+        if self.dom:
+            return "\n".join(self.dom)
+        return None
+
+    border_color: str = ""
+    glyph_color: str = ""
+    background: str = ""
+    glyph: Optional[str] = ""
     scale: float = 1.0
+
+    def content(self) -> str:
+        if self.dom:
+            return f"{self.name}.element"
+        return ""