flet-map 0.1.0.dev2__py3-none-any.whl → 0.2.0.dev45__py3-none-any.whl

flet_map/__init__.py

@@ -1,30 +1,41 @@
-from flet_map.circle_layer import CircleLayer, CircleMarker
-from flet_map.map import (
-    Map,
+from .circle_layer import CircleLayer, CircleMarker
+from .map import Map
+from .marker_layer import Marker, MarkerLayer
+from .polygon_layer import PolygonLayer, PolygonMarker
+from .polyline_layer import PolylineLayer, PolylineMarker
+from .rich_attribution import RichAttribution
+from .simple_attribution import SimpleAttribution
+from .source_attribution import (
+    ImageSourceAttribution,
+    SourceAttribution,
+    TextSourceAttribution,
+)
+from .tile_layer import TileLayer
+from .types import (
+    AttributionAlignment,
+    Camera,
+    CameraFit,
+    CursorKeyboardRotationConfiguration,
+    CursorRotationBehaviour,
+    DashedStrokePattern,
+    DottedStrokePattern,
+    FadeInTileDisplay,
+    InstantaneousTileDisplay,
+    InteractionConfiguration,
+    InteractionFlag,
+    KeyboardConfiguration,
     MapEvent,
     MapEventSource,
     MapHoverEvent,
-    MapInteractionConfiguration,
-    MapInteractiveFlag,
     MapLatitudeLongitude,
     MapLatitudeLongitudeBounds,
-    MapMultiFingerGesture,
-    MapPointerDeviceType,
     MapPointerEvent,
     MapPositionChangeEvent,
     MapTapEvent,
-)
-from flet_map.marker_layer import Marker, MarkerLayer
-from flet_map.polygon_layer import PolygonLayer, PolygonMarker
-from flet_map.polyline_layer import (
-    DashedStrokePattern,
-    DottedStrokePattern,
+    MultiFingerGesture,
     PatternFit,
-    PolylineLayer,
-    PolylineMarker,
     SolidStrokePattern,
+    StrokePattern,
+    TileDisplay,
+    TileLayerEvictErrorTileStrategy,
 )
-from flet_map.rich_attribution import RichAttribution
-from flet_map.simple_attribution import SimpleAttribution
-from flet_map.text_source_attribution import TextSourceAttribution
-from flet_map.tile_layer import MapTileLayerEvictErrorTileStrategy, TileLayer

flet_map/circle_layer.py

@@ -1,156 +1,63 @@
-from typing import Any, List, Optional, Union
+from typing import List, Optional
 
-from flet.core.control import Control, OptionalNumber
-from flet_map.map import MapLatitudeLongitude
-from flet_map.map_layer import MapLayer
-from flet.core.ref import Ref
-from flet.core.types import ColorEnums, ColorValue
+import flet as ft
 
+from .map_layer import MapLayer
+from .types import MapLatitudeLongitude
 
-class CircleMarker(Control):
+__all__ = ["CircleMarker", "CircleLayer"]
+
+
+@ft.control("CircleMarker")
+class CircleMarker(ft.Control):
+    """
+    A circular marker displayed on the Map at the specified location through the [`CircleLayer`][(p).].
+
+    Raises:
+        AssertionError: If the [`border_stroke_width`][(c).] is negative.
     """
-    A circular marker displayed on the Map at the specified location through the CircleLayer.
 
-    -----
+    radius: ft.Number
+    """The radius of the circle"""
+
+    coordinates: MapLatitudeLongitude
+    """The center coordinates of the circle"""
+
+    color: Optional[ft.ColorValue] = None
+    """The color of the circle area."""
+
+    border_color: Optional[ft.ColorValue] = None
+    """
+    The color of the circle border line.
+    
+    Needs [`border_stroke_width`][..] to be greater than `0.0` in order to be visible.
+    """
 
-    Online docs: https://flet.dev/docs/controls/mapcirclemarker
+    border_stroke_width: ft.Number = 0.0
+    """
+    The stroke width for the circle border. 
+    
+    Note:
+        Must be non-negative.
     """
 
-    def __init__(
-        self,
-        radius: Union[int, float],
-        coordinates: MapLatitudeLongitude,
-        color: Optional[ColorValue] = None,
-        border_color: Optional[ColorValue] = None,
-        border_stroke_width: OptionalNumber = None,
-        use_radius_in_meter: Optional[bool] = None,
-        #
-        # Control
-        #
-        ref: Optional[Ref] = None,
-        visible: Optional[bool] = None,
-        data: Any = None,
-    ):
-
-        Control.__init__(
-            self,
-            ref=ref,
-            visible=visible,
-            data=data,
-        )
-
-        self.coordinates = coordinates
-        self.color = color
-        self.border_color = border_color
-        self.border_stroke_width = border_stroke_width
-        self.use_radius_in_meter = use_radius_in_meter
-        self.radius = radius
-
-    def _get_control_name(self):
-        return "map_circle_marker"
+    use_radius_in_meter: bool = False
+    """
+    Whether the [`radius`][..] should use the unit meters.
+    """
 
     def before_update(self):
         super().before_update()
-        self._set_attr_json("coordinates", self.__coordinates)
-
-    # use_radius_in_meter
-    @property
-    def use_radius_in_meter(self) -> bool:
-        return self._get_attr("useRadiusInMeter", data_type="bool", def_value=False)
-
-    @use_radius_in_meter.setter
-    def use_radius_in_meter(self, value: Optional[bool]):
-        self._set_attr("useRadiusInMeter", value)
-
-    # color
-    @property
-    def color(self) -> Optional[ColorValue]:
-        return self.__color
-
-    @color.setter
-    def color(self, value: Optional[ColorValue]):
-        self.__color = value
-        self._set_enum_attr("color", value, ColorEnums)
-
-    # border_color
-    @property
-    def border_color(self) -> Optional[ColorValue]:
-        return self.__border_color
-
-    @border_color.setter
-    def border_color(self, value: Optional[ColorValue]):
-        self.__border_color = value
-        self._set_enum_attr("borderColor", value, ColorEnums)
-
-    # radius
-    @property
-    def radius(self) -> Union[int, float]:
-        return self._get_attr("radius", data_type="float")
-
-    @radius.setter
-    def radius(self, value: Union[int, float]):
-        self._set_attr("radius", value)
-
-    # border_stroke_width
-    @property
-    def border_stroke_width(self) -> OptionalNumber:
-        return self._get_attr("borderStrokeWidth", data_type="float")
-
-    @border_stroke_width.setter
-    def border_stroke_width(self, value: OptionalNumber):
-        assert value is None or value >= 0, "border_stroke_width cannot be negative"
-        self._set_attr("borderStrokeWidth", value)
-
-    # coordinates
-    @property
-    def coordinates(self) -> MapLatitudeLongitude:
-        return self.__coordinates
-
-    @coordinates.setter
-    def coordinates(self, value: MapLatitudeLongitude):
-        self.__coordinates = value
+        assert (
+            self.border_stroke_width >= 0
+        ), "border_stroke_width must be greater than or equal to 0"
 
 
+@ft.control("CircleLayer")
 class CircleLayer(MapLayer):
     """
-    A layer to display CircleMarkers.
-
-    -----
-
-    Online docs: https://flet.dev/docs/controls/mapcirclelayer
+    A layer to display [`CircleMarker`][(p).]s.
     """
 
-    def __init__(
-        self,
-        circles: List[CircleMarker],
-        #
-        # MapLayer
-        #
-        ref: Optional[Ref] = None,
-        visible: Optional[bool] = None,
-        data: Any = None,
-    ):
-
-        MapLayer.__init__(
-            self,
-            ref=ref,
-            visible=visible,
-            data=data,
-        )
-
-        self.circles = circles
-
-    def _get_control_name(self):
-        return "map_circle_layer"
-
-    def _get_children(self):
-        return self.__circles
-
-    # circles
-    @property
-    def circles(self) -> List[CircleMarker]:
-        return self.__circles
-
-    @circles.setter
-    def circles(self, value: List[CircleMarker]):
-        self.__circles = value
+    circles: List[CircleMarker]
+    """A list of [`CircleMarker`][(p).]s to display."""