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

flet_map/polyline_layer.py

@@ -1,292 +1,115 @@
-from dataclasses import dataclass
-from enum import Enum
-from typing import Any, List, Optional, Union
+from dataclasses import field
+from typing import 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, StrokeCap, StrokeJoin
+import flet as ft
 
+from .map_layer import MapLayer
+from .types import MapLatitudeLongitude, SolidStrokePattern, StrokePattern
 
-class PatternFit(Enum):
-    SCALE_DOWN = "scaleDown"
-    SCALE_UP = "scaleUp"
-    APPEND_DOT = "appendDot"
-    EXTEND_FINAL_DASH = "extendFinalDash"
+__all__ = ["PolylineMarker", "PolylineLayer"]
 
 
-@dataclass
-class StrokePattern:
-    pass
-
-
-@dataclass
-class SolidStrokePattern(StrokePattern):
-    def __post_init__(self):
-        self.type = "solid"
-
-
-@dataclass
-class DashedStrokePattern(StrokePattern):
-    segments: Optional[List[Union[float, int]]] = None
-    pattern_fit: Optional[PatternFit] = PatternFit.SCALE_UP
+@ft.control("PolylineMarker")
+class PolylineMarker(ft.Control):
+    """
+    A marker for the [`PolylineLayer`][(p).].
+    """
 
-    def __post_init__(self):
-        self.type = "dashed"
+    coordinates: list[MapLatitudeLongitude]
+    """
+    The list of coordinates for the polyline.
+    """
 
+    colors_stop: Optional[list[ft.Number]] = None
+    """
+    The stops for the [`gradient_colors`][..].
+    """
 
-@dataclass
-class DottedStrokePattern(StrokePattern):
-    spacing_factor: OptionalNumber = None
-    pattern_fit: Optional[PatternFit] = PatternFit.SCALE_UP
+    gradient_colors: Optional[list[ft.ColorValue]] = None
+    """
+    The List of colors in case a gradient should get used.
+    """
 
-    def __post_init__(self):
-        self.type = "dotted"
+    border_color: ft.ColorValue = ft.Colors.YELLOW
+    """
+    The border's color.
+    """
 
+    color: ft.ColorValue = ft.Colors.YELLOW
+    """
+    The color of the line stroke.
+    """
 
-class PolylineMarker(Control):
+    stroke_width: ft.Number = 1.0
+    """
+    The width of the stroke.
+    
+    Note:
+        Must be non-negative.
     """
-    A marker for the PolylineLayer.
 
-    -----
+    border_stroke_width: ft.Number = 0.0
+    """
+    The width of the stroke with of the line border.
+    
+    Note:
+        Must be non-negative.
+    """
 
-    Online docs: https://flet.dev/docs/controls/mappolylinemarker
+    use_stroke_width_in_meter: bool = False
+    """
+    Whether the stroke's width should have meters as unit.
     """
 
-    def __init__(
-        self,
-        coordinates: List[MapLatitudeLongitude],
-        colors_stop: Optional[List[Union[float, int]]] = None,
-        gradient_colors: Optional[List[str]] = None,
-        border_color: Optional[ColorValue] = None,
-        color: Optional[ColorValue] = None,
-        stroke_width: OptionalNumber = None,
-        border_stroke_width: OptionalNumber = None,
-        use_stroke_width_in_meter: Optional[bool] = None,
-        stroke_pattern: Optional[StrokePattern] = None,
-        stroke_cap: Optional[StrokeCap] = None,
-        stroke_join: Optional[StrokeJoin] = None,
-        #
-        # Control
-        #
-        ref: Optional[Ref] = None,
-        visible: Optional[bool] = None,
-        data: Any = None,
-    ):
-        Control.__init__(
-            self,
-            ref=ref,
-            visible=visible,
-            data=data,
-        )
+    stroke_pattern: StrokePattern = field(default_factory=lambda: SolidStrokePattern())
+    """
+    Determines whether the line should be solid, dotted, or dashed, and the
+    exact characteristics of each.
+    """
 
-        self.coordinates = coordinates
-        self.border_color = border_color
-        self.color = color
-        self.border_stroke_width = border_stroke_width
-        self.stroke_width = stroke_width
-        self.stroke_cap = stroke_cap
-        self.stroke_join = stroke_join
-        self.colors_stop = colors_stop
-        self.gradient_colors = gradient_colors
-        self.use_stroke_width_in_meter = use_stroke_width_in_meter
-        self.stroke_pattern = stroke_pattern
+    stroke_cap: ft.StrokeCap = ft.StrokeCap.ROUND
+    """
+    Style to use for line endings.
+    """
 
-    def _get_control_name(self):
-        return "map_polyline_marker"
+    stroke_join: ft.StrokeJoin = ft.StrokeJoin.ROUND
+    """
+    Style to use for line segment joins.
+    """
 
     def before_update(self):
         super().before_update()
-        self._set_attr_json("coordinates", self.__coordinates)
-        if isinstance(self.__colors_stop, list):
-            self._set_attr_json("colorsStop", self.__colors_stop)
-        if isinstance(self.__gradient_colors, list):
-            self._set_attr_json("gradientColors", self.__gradient_colors)
-        self._set_attr_json("strokePattern", self.__stroke_pattern)
-
-    # stroke_cap
-    @property
-    def stroke_cap(self) -> Optional[StrokeCap]:
-        return self.__stroke_cap
-
-    @stroke_cap.setter
-    def stroke_cap(self, value: Optional[StrokeCap]):
-        self.__stroke_cap = value
-        self._set_enum_attr("strokeCap", value, StrokeCap)
-
-    # gradient_colors
-    @property
-    def gradient_colors(self) -> Optional[List[str]]:
-        return self.__gradient_colors
-
-    @gradient_colors.setter
-    def gradient_colors(self, value: Optional[List[str]]):
-        self.__gradient_colors = value
-
-    # stroke_pattern
-    @property
-    def stroke_pattern(self) -> Optional[StrokePattern]:
-        return self.__stroke_pattern
-
-    @stroke_pattern.setter
-    def stroke_pattern(self, value: Optional[StrokePattern]):
-        self.__stroke_pattern = value
-
-    # colors_stop
-    @property
-    def colors_stop(self) -> Optional[List[Union[float, int]]]:
-        return self.__colors_stop
-
-    @colors_stop.setter
-    def colors_stop(self, value: Optional[List[Union[float, int]]]):
-        self.__colors_stop = value
-
-    # stroke_join
-    @property
-    def stroke_join(self) -> Optional[StrokeJoin]:
-        return self.__stroke_join
-
-    @stroke_join.setter
-    def stroke_join(self, value: Optional[StrokeJoin]):
-        self.__stroke_join = value
-        self._set_enum_attr("strokeJoin", value, StrokeJoin)
-
-    # use_stroke_width_in_meter
-    @property
-    def use_stroke_width_in_meter(self) -> bool:
-        return self._get_attr(
-            "useStrokeWidthInMeter", data_type="bool", def_value=False
-        )
-
-    @use_stroke_width_in_meter.setter
-    def use_stroke_width_in_meter(self, value: Optional[bool]):
-        self._set_attr("useStrokeWidthInMeter", 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)
-
-    # border_stroke_width
-    @property
-    def border_stroke_width(self) -> float:
-        return self._get_attr("borderStrokeWidth", data_type="float", def_value=0.0)
-
-    @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)
-
-    # stroke_width
-    @property
-    def stroke_width(self) -> float:
-        return self._get_attr("strokeWidth", data_type="float", def_value=1.0)
-
-    @stroke_width.setter
-    def stroke_width(self, value: OptionalNumber):
-        assert value is None or value >= 0, "stroke_width cannot be negative"
-        self._set_attr("strokeWidth", value)
-
-    # coordinates
-    @property
-    def coordinates(self) -> List[MapLatitudeLongitude]:
-        return self.__coordinates
-
-    @coordinates.setter
-    def coordinates(self, value: List[MapLatitudeLongitude]):
-        self.__coordinates = value
+        assert (
+            self.border_stroke_width >= 0
+        ), "border_stroke_width must be greater than or equal to 0"
+        assert self.stroke_width >= 0, "stroke_width must be greater than or equal to 0"
 
 
+@ft.control("PolylineLayer")
 class PolylineLayer(MapLayer):
     """
-    A layer to display PolylineMarkers.
-
-    -----
-
-    Online docs: https://flet.dev/docs/controls/mappolylinelayer
+    A layer to display [`PolylineMarker`][(p).]s.
     """
 
-    def __init__(
-        self,
-        polylines: List[PolylineMarker],
-        culling_margin: OptionalNumber = None,
-        min_hittable_radius: OptionalNumber = None,
-        simplify_tolerance: OptionalNumber = None,
-        #
-        # MapLayer
-        #
-        ref: Optional[Ref] = None,
-        visible: Optional[bool] = None,
-        data: Any = None,
-    ):
-        MapLayer.__init__(
-            self,
-            ref=ref,
-            visible=visible,
-            data=data,
-        )
-
-        self.polylines = polylines
-        self.culling_margin = culling_margin
-        self.min_hittable_radius = min_hittable_radius
-        self.simplify_tolerance = simplify_tolerance
-
-    def _get_control_name(self):
-        return "map_polyline_layer"
-
-    def _get_children(self):
-        return self.__polylines
-
-    # polylines
-    @property
-    def polylines(self) -> List[PolylineMarker]:
-        return self.__polylines
-
-    @polylines.setter
-    def polylines(self, value: List[PolylineMarker]):
-        self.__polylines = value
-
-    # culling_margin
-    @property
-    def culling_margin(self) -> float:
-        return self._get_attr("cullingMargin", data_type="float", def_value=10.0)
-
-    @culling_margin.setter
-    def culling_margin(self, value: OptionalNumber):
-        self._set_attr("cullingMargin", value)
-
-    # simplification_tolerance
-    @property
-    def simplification_tolerance(self) -> float:
-        return self._get_attr(
-            "simplificationTolerance", data_type="float", def_value=0.4
-        )
+    polylines: list[PolylineMarker]
+    """
+    List of [`PolylineMarker`][(p).]s to be drawn. 
+    """
 
-    @simplification_tolerance.setter
-    def simplification_tolerance(self, value: OptionalNumber):
-        self._set_attr("simplificationTolerance", value)
+    culling_margin: ft.Number = 10.0
+    """
+    Acceptable extent outside of viewport before culling polyline segments.
+    """
 
-    # min_hittable_radius
-    @property
-    def min_hittable_radius(self) -> float:
-        return self._get_attr("minHittableRadius", data_type="float", def_value=10.0)
+    min_hittable_radius: ft.Number = 10.0
+    """
+    The minimum radius of the hittable area around each polyline in logical pixels.
+    
+    The entire visible area is always hittable, but if the visible area is
+    smaller than this, then this will be the hittable area.
+    """
 
-    @min_hittable_radius.setter
-    def min_hittable_radius(self, value: OptionalNumber):
-        self._set_attr("minHittableRadius", value)
+    simplification_tolerance: ft.Number = 0.3
+    """
+    
+    """

flet_map/rich_attribution.py

@@ -1,141 +1,63 @@
-from enum import Enum
-from typing import Any, List, Optional
+from dataclasses import field
+from typing import List, Optional
 
-from flet.core.border_radius import BorderRadius
-from flet.core.control import OptionalNumber
-from flet_map.map_layer import MapLayer
-from flet_map.text_source_attribution import TextSourceAttribution
-from flet.core.ref import Ref
-from flet.core.types import ColorEnums, ColorValue
+import flet as ft
 
+from .map_layer import MapLayer
+from .source_attribution import SourceAttribution
+from .types import AttributionAlignment
 
-class AttributionAlignment(Enum):
-    BOTTOM_LEFT = "bottomLeft"
-    BOTTOM_RIGHT = "bottomRight"
+__all__ = ["RichAttribution"]
 
 
+@ft.control("RichAttribution")
 class RichAttribution(MapLayer):
     """
-    An animated and interactive attribution layer that supports both logos/images and text
-    (displayed in a popup controlled by an icon button adjacent to the logos).
-
-    -----
-
-    Online docs: https://flet.dev/docs/controls/maprichattribution
+    An animated and interactive attribution layer that supports both images and text
+    (displayed in a popup controlled by an icon button adjacent to the images).
     """
 
-    def __init__(
-        self,
-        attributions: List[TextSourceAttribution],
-        alignment: Optional[AttributionAlignment] = None,
-        popup_bgcolor: Optional[ColorValue] = None,
-        popup_border_radius: Optional[BorderRadius] = None,
-        popup_initial_display_duration: Optional[int] = None,
-        permanent_height: OptionalNumber = None,
-        show_flutter_map_attribution: Optional[bool] = None,
-        #
-        # MapLayer
-        #
-        ref: Optional[Ref] = None,
-        visible: Optional[bool] = None,
-        data: Any = None,
-    ):
-
-        MapLayer.__init__(
-            self,
-            ref=ref,
-            visible=visible,
-            data=data,
-        )
-
-        self.attributions = attributions
-        self.alignment = alignment
-        self.popup_bgcolor = popup_bgcolor
-        self.permanent_height = permanent_height
-        self.show_flutter_map_attribution = show_flutter_map_attribution
-        self.popup_border_radius = popup_border_radius
-        self.popup_initial_display_duration = popup_initial_display_duration
-
-    def _get_control_name(self):
-        return "map_rich_attribution"
-
-    def _get_children(self):
-        return self.attributions
-
-    def before_update(self):
-        super().before_update()
-        self._set_attr_json("popupBorderRadius", self.__popup_border_radius)
-        self._set_attr_json("alignment", self.__alignment)
-
-    # permanent_height
-    @property
-    def permanent_height(self) -> float:
-        return self._get_attr("permanentHeight", data_type="float", def_value=24.0)
-
-    @permanent_height.setter
-    def permanent_height(self, value: OptionalNumber):
-        assert value is None or value >= 0, "permanent_height cannot be negative"
-        self._set_attr("permanentHeight", value)
-
-    # popup_initial_display_duration
-    @property
-    def popup_initial_display_duration(self) -> int:
-        return self._get_attr(
-            "popupInitialDisplayDuration", data_type="int", def_value=0
-        )
-
-    @popup_initial_display_duration.setter
-    def popup_initial_display_duration(self, value: Optional[int]):
-        assert (
-            value is None or value >= 0
-        ), "popup_initial_display_duration cannot be negative"
-        self._set_attr("popupInitialDisplayDuration", value)
-
-    # popup_border_radius
-    @property
-    def popup_border_radius(self) -> Optional[BorderRadius]:
-        return self.__popup_border_radius
-
-    @popup_border_radius.setter
-    def popup_border_radius(self, value: Optional[BorderRadius]):
-        self.__popup_border_radius = value
-
-    # alignment
-    @property
-    def alignment(self) -> Optional[AttributionAlignment]:
-        return self.__alignment
-
-    @alignment.setter
-    def alignment(self, value: Optional[AttributionAlignment]):
-        self.__alignment = value
-        self._set_enum_attr("alignment", value, AttributionAlignment)
+    attributions: List[SourceAttribution]
+    """
+    List of attributions to display.
+    
+    [`TextSourceAttribution`][(p).]s are shown in a popup box, 
+    unlike [`ImageSourceAttribution`][(p).], which are visible permanently.
+    """
 
-    # show_flutter_map_attribution
-    @property
-    def show_flutter_map_attribution(self) -> bool:
-        return self._get_attr(
-            "showFlutterMapAttribution", data_type="bool", def_value=True
-        )
+    alignment: Optional[AttributionAlignment] = None
+    """
+    The position in which to anchor this attribution control.
+    """
 
-    @show_flutter_map_attribution.setter
-    def show_flutter_map_attribution(self, value: Optional[bool]):
-        self._set_attr("showFlutterMapAttribution", value)
+    popup_bgcolor: Optional[ft.ColorValue] = ft.Colors.SURFACE
+    """
+    The color to use as the popup box's background color.
+    """
 
-    # popup_bgcolor
-    @property
-    def popup_bgcolor(self) -> Optional[str]:
-        return self.__popup_bgcolor
+    popup_border_radius: Optional[ft.BorderRadiusValue] = None
+    """
+    The radius of the edges of the popup box.
+    """
 
-    @popup_bgcolor.setter
-    def popup_bgcolor(self, value: Optional[str]):
-        self.__popup_bgcolor = value
-        self._set_enum_attr("popupBgcolor", value, ColorEnums)
+    popup_initial_display_duration: ft.DurationValue = field(
+        default_factory=lambda: ft.Duration()
+    )
+    """
+    The popup box will be open by default and be hidden this long after the map is initialised.
+    
+    This is useful with certain sources/tile servers that make immediate
+    attribution mandatory and are not attributed with a permanently visible [`ImageSourceAttribution`][(p).].
+    """
 
-    # attributions
-    @property
-    def attributions(self) -> List[TextSourceAttribution]:
-        return self.__attributions
+    permanent_height: ft.Number = 24.0
+    """
+    The height of the permanent row in which is found the popup menu toggle button.
+    Also determines spacing between the items within the row.
+    """
 
-    @attributions.setter
-    def attributions(self, value: List[TextSourceAttribution]):
-        self.__attributions = value
+    show_flutter_map_attribution: bool = True
+    """
+    Whether to add an additional attribution logo and text for [`flutter-map`](https://docs.fleaflet.dev/),
+    on which 'flet-map' package is based for map-renderings.
+    """

flet_map/simple_attribution.py

@@ -1,86 +1,35 @@
-from typing import Any, Optional
+from dataclasses import field
+from typing import Union
 
-from flet.core.alignment import Alignment
-from flet_map.map_layer import MapLayer
-from flet.core.ref import Ref
-from flet.core.types import ColorEnums, ColorValue, OptionalControlEventCallable
+import flet as ft
 
+from .map_layer import MapLayer
 
+__all__ = ["SimpleAttribution"]
+
+
+@ft.control("SimpleAttribution")
 class SimpleAttribution(MapLayer):
     """
     A simple attribution layer displayed on the Map.
-
-    -----
-
-    Online docs: https://flet.dev/docs/controls/mapsimpleattribution
     """
 
-    def __init__(
-        self,
-        text: str,
-        alignment: Optional[Alignment] = None,
-        bgcolor: Optional[ColorValue] = None,
-        on_click: OptionalControlEventCallable = None,
-        #
-        # MapLayer
-        #
-        ref: Optional[Ref] = None,
-        visible: Optional[bool] = None,
-        data: Any = None,
-    ):
-
-        MapLayer.__init__(
-            self,
-            ref=ref,
-            visible=visible,
-            data=data,
-        )
-
-        self.text = text
-        self.alignment = alignment
-        self.bgcolor = bgcolor
-        self.on_click = on_click
-
-    def _get_control_name(self):
-        return "map_simple_attribution"
-
-    def before_update(self):
-        super().before_update()
-        self._set_attr_json("alignment", self.__alignment)
-
-    # alignment
-    @property
-    def alignment(self) -> Optional[Alignment]:
-        return self.__alignment
-
-    @alignment.setter
-    def alignment(self, value: Optional[Alignment]):
-        self.__alignment = value
-
-    # bgcolor
-    @property
-    def bgcolor(self) -> Optional[ColorValue]:
-        return self.__bgcolor
-
-    @bgcolor.setter
-    def bgcolor(self, value: Optional[ColorValue]):
-        self.__bgcolor = value
-        self._set_enum_attr("bgcolor", value, ColorEnums)
-
-    # text
-    @property
-    def text(self) -> str:
-        return self._get_attr("text")
+    text: Union[str, ft.Text]
+    """
+    The attribution message to be displayed.
+    
+    Value is of type `str` and `ft.Text`.
+    """
 
-    @text.setter
-    def text(self, value: str):
-        self._set_attr("text", value)
+    alignment: ft.Alignment = field(default_factory=lambda: ft.Alignment.bottom_right())
+    """
+    The alignment of this attribution on the map.
+    """
 
-    # on_click
-    @property
-    def on_change(self) -> OptionalControlEventCallable:
-        return self._get_event_handler("click")
+    bgcolor: ft.ColorValue = ft.Colors.SURFACE
+    """
+    The color of the box containing the `text`.
+    """
 
-    @on_change.setter
-    def on_change(self, handler: OptionalControlEventCallable):
-        self._add_event_handler("click", handler)
+    on_click: ft.OptionalControlEventHandler["SimpleAttribution"] = None
+    """Fired when this attribution is clicked/pressed."""