flet-map 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

flet_map/tile_layer.py

@@ -0,0 +1,278 @@
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from flet.core.control import OptionalNumber
+from flet_map.map import MapLatitudeLongitudeBounds
+from flet_map.map_layer import MapLayer
+from flet.core.ref import Ref
+from flet.core.types import OptionalControlEventCallable
+
+
+class MapTileLayerEvictErrorTileStrategy(Enum):
+    DISPOSE = "dispose"
+    NOT_VISIBLE = "notVisible"
+    NOT_VISIBLE_RESPECT_MARGIN = "notVisibleRespectMargin"
+
+
+class TileLayer(MapLayer):
+    """
+    The Map's main layer.
+    Displays square raster images in a continuous grid, sourced from the provided utl_template.
+
+    -----
+
+    Online docs: https://flet.dev/docs/controls/maptilelayer
+    """
+
+    def __init__(
+        self,
+        url_template: str,
+        fallback_url: Optional[str] = None,
+        subdomains: Optional[List[str]] = None,
+        tile_bounds: Optional[MapLatitudeLongitudeBounds] = None,
+        tile_size: OptionalNumber = None,
+        min_native_zoom: Optional[int] = None,
+        max_native_zoom: Optional[int] = None,
+        zoom_reverse: Optional[bool] = None,
+        zoom_offset: OptionalNumber = None,
+        keep_buffer: Optional[int] = None,
+        pan_buffer: Optional[int] = None,
+        enable_tms: Optional[bool] = None,
+        keep_alive: Optional[bool] = None,
+        enable_retina_mode: Optional[bool] = None,
+        additional_options: Optional[Dict[str, str]] = None,
+        max_zoom: OptionalNumber = None,
+        min_zoom: OptionalNumber = None,
+        error_image_src: Optional[str] = None,
+        evict_error_tile_strategy: Optional[MapTileLayerEvictErrorTileStrategy] = None,
+        on_image_error: OptionalControlEventCallable = None,
+        #
+        # MapLayer
+        #
+        ref: Optional[Ref] = None,
+        visible: Optional[bool] = None,
+        data: Any = None,
+    ):
+
+        MapLayer.__init__(
+            self,
+            ref=ref,
+            visible=visible,
+            data=data,
+        )
+
+        self.url_template = url_template
+        self.fallback_url = fallback_url
+        self.tile_size = tile_size
+        self.min_native_zoom = min_native_zoom
+        self.max_native_zoom = max_native_zoom
+        self.zoom_reverse = zoom_reverse
+        self.zoom_offset = zoom_offset
+        self.keep_buffer = keep_buffer
+        self.pan_buffer = pan_buffer
+        self.enable_tms = enable_tms
+        self.keep_alive = keep_alive
+        self.max_zoom = max_zoom
+        self.min_zoom = min_zoom
+        self.error_image_src = error_image_src
+        self.enable_retina_mode = enable_retina_mode
+        self.on_image_error = on_image_error
+        self.tile_bounds = tile_bounds
+        self.evict_error_tile_strategy = evict_error_tile_strategy
+        self.subdomains = subdomains
+        self.additional_options = additional_options
+
+    def _get_control_name(self):
+        return "map_tile_layer"
+
+    def before_update(self):
+        super().before_update()
+        assert self.url_template, "url_template is required"
+        if isinstance(self.__tile_bounds, MapLatitudeLongitudeBounds):
+            self._set_attr_json("tileBounds", self.__tile_bounds)
+        if isinstance(self.__subdomains, list):
+            self._set_attr_json("subdomains", self.__subdomains)
+        if isinstance(self.__additional_options, dict):
+            self._set_attr_json("additionalOptions", self.__additional_options)
+
+    # url_template
+    @property
+    def url_template(self) -> str:
+        return self._get_attr("urlTemplate")
+
+    @url_template.setter
+    def url_template(self, value: str):
+        self._set_attr("urlTemplate", value)
+
+    # fallback_url
+    @property
+    def fallback_url(self) -> Optional[str]:
+        return self._get_attr("fallbackUrl")
+
+    @fallback_url.setter
+    def fallback_url(self, value: Optional[str]):
+        self._set_attr("fallbackUrl", value)
+
+    # subdomains
+    @property
+    def subdomains(self) -> Optional[List[str]]:
+        return self.__subdomains
+
+    @subdomains.setter
+    def subdomains(self, value: Optional[List[str]]):
+        self.__subdomains = value
+
+    # additional_options
+    @property
+    def additional_options(self) -> Optional[Dict[str, str]]:
+        return self.__additional_options
+
+    @additional_options.setter
+    def additional_options(self, value: Optional[Dict[str, str]]):
+        self.__additional_options = value
+
+    # tile_bounds
+    @property
+    def tile_bounds(self) -> Optional[MapLatitudeLongitudeBounds]:
+        return self.__tile_bounds
+
+    @tile_bounds.setter
+    def tile_bounds(self, value: Optional[MapLatitudeLongitudeBounds]):
+        self.__tile_bounds = value
+
+    # tile_size
+    @property
+    def tile_size(self) -> float:
+        return self._get_attr("tileSize", data_type="float", def_value=256.0)
+
+    @tile_size.setter
+    def tile_size(self, value: OptionalNumber):
+        assert value is None or value >= 0, "tile_size cannot be negative"
+        self._set_attr("tileSize", value)
+
+    # min_native_zoom
+    @property
+    def min_native_zoom(self) -> int:
+        return self._get_attr("minNativeZoom", data_type="int", def_value=0.0)
+
+    @min_native_zoom.setter
+    def min_native_zoom(self, value: Optional[int]):
+        assert value is None or value >= 0, "min_native_zoom cannot be negative"
+        self._set_attr("minNativeZoom", value)
+
+    # max_native_zoom
+    @property
+    def max_native_zoom(self) -> int:
+        return self._get_attr("maxNativeZoom", data_type="int", def_value=19)
+
+    @max_native_zoom.setter
+    def max_native_zoom(self, value: Optional[int]):
+        assert value is None or value >= 0, "max_native_zoom cannot be negative"
+        self._set_attr("maxNativeZoom", value)
+
+    # zoom_reverse
+    @property
+    def zoom_reverse(self) -> bool:
+        return self._get_attr("zoomReverse", data_type="bool", def_value=False)
+
+    @zoom_reverse.setter
+    def zoom_reverse(self, value: Optional[bool]):
+        self._set_attr("zoomReverse", value)
+
+    # zoom_offset
+    @property
+    def zoom_offset(self) -> float:
+        return self._get_attr("zoomOffset", data_type="float", def_value=0.0)
+
+    @zoom_offset.setter
+    def zoom_offset(self, value: OptionalNumber):
+        assert value is None or value >= 0, "zoom_offset cannot be negative"
+        self._set_attr("zoomOffset", value)
+
+    # keep_buffer
+    @property
+    def keep_buffer(self) -> int:
+        return self._get_attr("keepBuffer", data_type="int", def_value=2)
+
+    @keep_buffer.setter
+    def keep_buffer(self, value: Optional[int]):
+        self._set_attr("keepBuffer", value)
+
+    # pan_buffer
+    @property
+    def pan_buffer(self) -> int:
+        return self._get_attr("panBuffer", data_type="int", def_value=2)
+
+    @pan_buffer.setter
+    def pan_buffer(self, value: Optional[int]):
+        self._set_attr("panBuffer", value)
+
+    # enable_tms
+    @property
+    def enable_tms(self) -> bool:
+        return self._get_attr("enableTms", data_type="bool", def_value=False)
+
+    @enable_tms.setter
+    def enable_tms(self, value: Optional[bool]):
+        self._set_attr("enableTms", value)
+
+    # enable_retina_mode
+    @property
+    def enable_retina_mode(self) -> bool:
+        return self._get_attr("enableRetinaMode", data_type="bool", def_value=False)
+
+    @enable_retina_mode.setter
+    def enable_retina_mode(self, value: Optional[bool]):
+        self._set_attr("enableRetinaMode", value)
+
+    # max_zoom
+    @property
+    def max_zoom(self) -> float:
+        return self._get_attr("maxZoom", data_type="float", def_value=float("inf"))
+
+    @max_zoom.setter
+    def max_zoom(self, value: OptionalNumber):
+        assert value is None or value >= 0, "max_zoom cannot be negative"
+        self._set_attr("maxZoom", value)
+
+    # min_zoom
+    @property
+    def min_zoom(self) -> float:
+        return self._get_attr("minZoom", data_type="float", def_value=0.0)
+
+    @min_zoom.setter
+    def min_zoom(self, value: OptionalNumber):
+        assert value is None or value >= 0, "min_zoom cannot be negative"
+        self._set_attr("minZoom", value)
+
+    # error_image_src
+    @property
+    def error_image_src(self) -> Optional[str]:
+        return self._get_attr("errorImageSrc")
+
+    @error_image_src.setter
+    def error_image_src(self, value: Optional[str]):
+        self._set_attr("errorImageSrc", value)
+
+    # evict_error_tile_strategy
+    @property
+    def evict_error_tile_strategy(self) -> Optional[MapTileLayerEvictErrorTileStrategy]:
+        return self.__evict_error_tile_strategy
+
+    @evict_error_tile_strategy.setter
+    def evict_error_tile_strategy(
+        self, value: Optional[MapTileLayerEvictErrorTileStrategy]
+    ):
+        self.__evict_error_tile_strategy = value
+        self._set_enum_attr(
+            "evictErrorTileStrategy", value, MapTileLayerEvictErrorTileStrategy
+        )
+
+    # on_image_error
+    @property
+    def on_image_error(self) -> OptionalControlEventCallable:
+        return self._get_event_handler("imageError")
+
+    @on_image_error.setter
+    def on_image_error(self, handler: OptionalControlEventCallable):
+        self._add_event_handler("imageError", handler)

flet_map-0.1.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.2
+Name: flet-map
+Version: 0.1.0
+Summary: Map control for Flet
+Author-email: Flet contributors <hello@flet.dev>
+Project-URL: Homepage, https://flet.dev
+Project-URL: Documentation, https://flet.dev/docs/controls/map
+Project-URL: Repository, https://github.com/flet-dev/flet-map
+Project-URL: Issues, https://github.com/flet-dev/flet-map/issues
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: flet>=0.25.2
+
+# Map control for Flet
+
+`Map` control for Flet.
+
+## Usage
+
+Add `flet-map` as dependency (`pyproject.toml` or `requirements.txt`) to your Flet project.
+
+## Example
+
+```py
+
+import random
+import flet as ft
+import flet_map as map
+
+
+def main(page: ft.Page):
+    marker_layer_ref = ft.Ref[map.MarkerLayer]()
+    circle_layer_ref = ft.Ref[map.CircleLayer]()
+
+    def handle_tap(e: map.MapTapEvent):
+        print(e)
+        if e.name == "tap":
+            marker_layer_ref.current.markers.append(
+                map.Marker(
+                    content=ft.Icon(
+                        ft.Icons.LOCATION_ON, color=ft.cupertino_colors.DESTRUCTIVE_RED
+                    ),
+                    coordinates=e.coordinates,
+                )
+            )
+        elif e.name == "secondary_tap":
+            circle_layer_ref.current.circles.append(
+                map.CircleMarker(
+                    radius=random.randint(5, 10),
+                    coordinates=e.coordinates,
+                    color=ft.Colors.random_color(),
+                    border_color=ft.Colors.random_color(),
+                    border_stroke_width=4,
+                )
+            )
+        page.update()
+
+    def handle_event(e: map.MapEvent):
+        print(e)
+
+    page.add(
+        ft.Text("Click anywhere to add a Marker, right-click to add a CircleMarker."),
+        map.Map(
+            expand=True,
+            initial_center=map.MapLatitudeLongitude(15, 10),
+            initial_zoom=4.2,
+            interaction_configuration=map.MapInteractionConfiguration(
+                flags=map.MapInteractiveFlag.ALL
+            ),
+            on_init=lambda e: print(f"Initialized Map"),
+            on_tap=handle_tap,
+            on_secondary_tap=handle_tap,
+            on_long_press=handle_tap,
+            on_event=lambda e: print(e),
+            layers=[
+                map.TileLayer(
+                    url_template="https://tile.openstreetmap.org/{z}/{x}/{y}.png",
+                    on_image_error=lambda e: print("TileLayer Error"),
+                ),
+                map.RichAttribution(
+                    attributions=[
+                        map.TextSourceAttribution(
+                            text="OpenStreetMap Contributors",
+                            on_click=lambda e: e.page.launch_url(
+                                "https://openstreetmap.org/copyright"
+                            ),
+                        ),
+                        map.TextSourceAttribution(
+                            text="Flet",
+                            on_click=lambda e: e.page.launch_url("https://flet.dev"),
+                        ),
+                    ]
+                ),
+                map.SimpleAttribution(
+                    text="Flet",
+                    alignment=ft.alignment.top_right,
+                    on_click=lambda e: print("Clicked SimpleAttribution"),
+                ),
+                map.MarkerLayer(
+                    ref=marker_layer_ref,
+                    markers=[
+                        map.Marker(
+                            content=ft.Icon(ft.Icons.LOCATION_ON),
+                            coordinates=map.MapLatitudeLongitude(30, 15),
+                        ),
+                        map.Marker(
+                            content=ft.Icon(ft.Icons.LOCATION_ON),
+                            coordinates=map.MapLatitudeLongitude(10, 10),
+                        ),
+                        map.Marker(
+                            content=ft.Icon(ft.Icons.LOCATION_ON),
+                            coordinates=map.MapLatitudeLongitude(25, 45),
+                        ),
+                    ],
+                ),
+                map.CircleLayer(
+                    ref=circle_layer_ref,
+                    circles=[
+                        map.CircleMarker(
+                            radius=10,
+                            coordinates=map.MapLatitudeLongitude(16, 24),
+                            color=ft.Colors.RED,
+                            border_color=ft.Colors.BLUE,
+                            border_stroke_width=4,
+                        ),
+                    ],
+                ),
+                map.PolygonLayer(
+                    polygons=[
+                        map.PolygonMarker(
+                            label="Popular Touristic Area",
+                            label_text_style=ft.TextStyle(
+                                color=ft.Colors.BLACK,
+                                size=15,
+                                weight=ft.FontWeight.BOLD,
+                            ),
+                            color=ft.Colors.with_opacity(0.3, ft.Colors.BLUE),
+                            coordinates=[
+                                map.MapLatitudeLongitude(10, 10),
+                                map.MapLatitudeLongitude(30, 15),
+                                map.MapLatitudeLongitude(25, 45),
+                            ],
+                        ),
+                    ],
+                ),
+                map.PolylineLayer(
+                    polylines=[
+                        map.PolylineMarker(
+                            border_stroke_width=3,
+                            border_color=ft.Colors.RED,
+                            gradient_colors=[ft.Colors.BLACK, ft.Colors.BLACK],
+                            color=ft.Colors.with_opacity(0.6, ft.Colors.GREEN),
+                            coordinates=[
+                                map.MapLatitudeLongitude(10, 10),
+                                map.MapLatitudeLongitude(30, 15),
+                                map.MapLatitudeLongitude(25, 45),
+                            ],
+                        ),
+                    ],
+                ),
+            ],
+        ),
+    )
+
+
+ft.app(main)
+```

flet_map-0.1.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+flet_map/__init__.py,sha256=xmGk-KtjPbkpMoj3kR40zmzTQF4mGwtq_lyC0M8groQ,927
+flet_map/circle_layer.py,sha256=TBydZRXPvRvdkIutUMux8hQQwVzeb-yYjVjkByb68os,4111
+flet_map/map.py,sha256=MkRKtESgSgo2DWjCQAiwOWt7ywR6L_NF3CNwEeidEfw,23150
+flet_map/map_layer.py,sha256=9Uwn3vzuDevpBjH9gH8YIA0xnqog7u1rLiZEpVPI_wM,490
+flet_map/marker_layer.py,sha256=PXNPTxmpzFVu3-ltPjsaPBbTLX8EwVOXX9slv_S9Dpc,4576
+flet_map/polygon_layer.py,sha256=ovxQX_qzg6CJ2hfZy2VWmz68Z1eoiohduPs63ZxjIUo,7877
+flet_map/polyline_layer.py,sha256=eCTxA64Of-Q8V69XetHdHlIQl9aDQz-QiYYurTUQxp0,8560
+flet_map/rich_attribution.py,sha256=1-GqK75MiDN0EU4YUCqFLvcXFNmpoulHwVF4ai-0hv8,4575
+flet_map/simple_attribution.py,sha256=31b6WEwSOZWDO5WtEpYcV8mI-vaXR5DPqbOc_tDCNLA,2149
+flet_map/text_source_attribution.py,sha256=BPqT2Ph8kISnBnfzs5v_i-uKEP5JZfxwe-wZ7qEdBRE,2340
+flet_map/tile_layer.py,sha256=7pNIvrKbzggry7oUXWYNt5xySybEJNe3e2FUAS2Q42s,9113
+flutter/flet_map/CHANGELOG.md,sha256=66sWepPaeTc9_lzcYIGU55AlxSU5Z1XVtknXpzd_-p8,40
+flutter/flet_map/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+flutter/flet_map/README.md,sha256=ABBaDRlbz2HalnmHeD_Y8KyT1JCh4Axkl1cqv4vFZqI,56
+flutter/flet_map/analysis_options.yaml,sha256=32kjGAc-zF87inWaH5M46yGZWQDTwrwfvNLHeAocfG4,154
+flutter/flet_map/pubspec.lock,sha256=U5N7CBWNVdN5z-4SMc1YjF6LJKSj77OK87SQ_Jj1CyA,24554
+flutter/flet_map/pubspec.yaml,sha256=8YTcl_p4ZoQmKhpY4fiFOPKsnag9LnPhl3k_eOKARtU,493
+flutter/flet_map/lib/flet_map.dart,sha256=PdaEb2aoyBwp978wal3-9I0docgp0eUzcAub3kw7MUs,91
+flutter/flet_map/lib/src/circle_layer.dart,sha256=HYfop2lkeZnxb4tXtUWps1FMrQWiuHkQRP8QEinh3pI,1482
+flutter/flet_map/lib/src/create_control.dart,sha256=JjtTXKyYAxbrA3Ys0P6OmC9wtplFr-iezzr3N3gTtaQ,1814
+flutter/flet_map/lib/src/map.dart,sha256=EUOWt0LDRXodGl0B-fjTUbKt48JCAp2ruWuFSkHjw8o,5152
+flutter/flet_map/lib/src/marker_layer.dart,sha256=KYk9Sdo8cV8objkIjmwnurx0ByKlCrAoHy09h_i_k2k,1731
+flutter/flet_map/lib/src/polygon_layer.dart,sha256=iuYUwu2qNKT-duzdxbYtffAal9PS6wDOfYALLuknAOE,2667
+flutter/flet_map/lib/src/polyline_layer.dart,sha256=pDBoScHBhOpRjSOddW09OYLDP09V211T4UEQS17hTgM,3122
+flutter/flet_map/lib/src/rich_attribution.dart,sha256=jFmjrvSZjem5aXFP22SXmtwckQYkYoDc-b2M441W54U,2226
+flutter/flet_map/lib/src/simple_attribution.dart,sha256=9Ac2pL7MaIDlZ-e5SrHHRDwxgx9D3YZwRh-5buLMXew,1141
+flutter/flet_map/lib/src/text_source_attribution.dart,sha256=fwqZ_T9dvRZdBgaMGSNJkjtdLAodKR3VNSgw9guL06g,865
+flutter/flet_map/lib/src/tile_layer.dart,sha256=UqvnaCr4QquUs5KnuBB7la085cCfGWvjaqjX6E2qIO0,3092
+flutter/flet_map/lib/src/utils/attribution_alignment.dart,sha256=xuj188pAUG2mfcBVNbyUSZGVz-dlJua-bnu5fdojMQQ,382
+flutter/flet_map/lib/src/utils/map.dart,sha256=c8ynRMHtl6GGEgXJYL0Vwk8LYdKW-3MsW0ybz6LMnCw,9205
+flet_map-0.1.0.dist-info/METADATA,sha256=AtoHA3SzxxSj_vEzn1KZp6EOxuUS8o5gXObJTNqsGGQ,6245
+flet_map-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+flet_map-0.1.0.dist-info/top_level.txt,sha256=HjaN5dGb0-hj6ciqBzy1aqisp22P0mbT98qC8rvoEjg,17
+flet_map-0.1.0.dist-info/RECORD,,

{flet_map-0.0.1.dist-info → flet_map-0.1.0.dist-info}/WHEEL

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

flet_map-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+flet_map
+flutter

flutter/flet_map/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.1.0
+
+Initial release of the package.