sibi-dst 0.3.40__py3-none-any.whl → 0.3.43__py3-none-any.whl

sibi_dst/df_helper/__init__.py

@@ -3,11 +3,13 @@ from __future__ import annotations
 from ._df_helper import DfHelper
 from ._parquet_artifact import ParquetArtifact
 from ._parquet_reader import ParquetReader
+from ._artifact_updater_multi_wrapper import ArtifactUpdaterMultiWrapper
 #from .data_cleaner import DataCleaner
 
 __all__ = [
     'DfHelper',
     'ParquetArtifact',
     'ParquetReader',
+    'ArtifactUpdaterMultiWrapper',
     #'DataCleaner'
 ]

sibi_dst/df_helper/_artifact_updater_multi_wrapper.py

@@ -0,0 +1,262 @@
+import asyncio
+import logging
+import datetime
+import psutil
+import time
+from functools import total_ordering
+from collections import defaultdict
+from contextlib import asynccontextmanager
+import signal
+from sibi_dst.utils import Logger
+
+@total_ordering
+class PrioritizedItem:
+    def __init__(self, priority, artifact):
+        self.priority = priority
+        self.artifact = artifact
+
+    def __lt__(self, other):
+        return self.priority < other.priority
+
+    def __eq__(self, other):
+        return self.priority == other.priority
+
+class ArtifactUpdaterMultiWrapper:
+    def __init__(self, wrapped_classes=None, debug=False, **kwargs):
+        self.wrapped_classes = wrapped_classes or {}
+        self.debug = debug
+        self.logger = kwargs.setdefault('logger',Logger.default_logger(logger_name=self.__class__.__name__))
+        self.logger.set_level(logging.DEBUG if debug else logging.INFO)
+
+        today = datetime.datetime.today()
+        self.today_str = today.strftime('%Y-%m-%d')
+        self.current_year_starts_on_str = datetime.date(today.year, 1, 1).strftime('%Y-%m-%d')
+        self.parquet_start_date = kwargs.get('parquet_start_date', self.current_year_starts_on_str)
+        self.parquet_end_date = kwargs.get('parquet_end_date', self.today_str)
+
+        # track concurrency and locks
+        self.locks = {}
+        self.worker_heartbeat = defaultdict(float)
+
+        # graceful shutdown handling
+        loop = asyncio.get_event_loop()
+        self.register_signal_handlers(loop)
+
+        # dynamic scaling config
+        self.min_workers = kwargs.get('min_workers', 1)
+        self.max_workers = kwargs.get('max_workers', 8)
+        self.memory_per_worker_gb = kwargs.get('memory_per_worker_gb', 1)  # default 2GB per worker
+        self.monitor_interval = kwargs.get('monitor_interval', 10)  # default monitor interval in seconds
+        self.retry_attempts = kwargs.get('retry_attempts', 3)
+        self.update_timeout_seconds = kwargs.get('update_timeout_seconds', 600)
+        self.lock_acquire_timeout_seconds = kwargs.get('lock_acquire_timeout_seconds', 10)
+
+    def register_signal_handlers(self, loop):
+        for sig in (signal.SIGINT, signal.SIGTERM):
+            loop.add_signal_handler(sig, lambda: asyncio.create_task(self.shutdown()))
+
+    async def shutdown(self):
+        self.logger.info("Shutdown signal received. Cleaning up...")
+        tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+        [task.cancel() for task in tasks]
+        await asyncio.gather(*tasks, return_exceptions=True)
+        self.logger.info("Shutdown complete.")
+
+    def get_lock_for_artifact(self, artifact):
+        artifact_key = artifact.__class__.__name__
+        if artifact_key not in self.locks:
+            self.locks[artifact_key] = asyncio.Lock()
+        return self.locks[artifact_key]
+
+    def get_artifacts(self, data_type):
+        if data_type not in self.wrapped_classes:
+            raise ValueError(f"Unsupported data type: {data_type}")
+
+        return [
+            artifact_class(
+                parquet_start_date=self.parquet_start_date,
+                parquet_end_date=self.parquet_end_date,
+                logger=self.logger,
+                debug=self.debug
+            )
+            for artifact_class in self.wrapped_classes[data_type]
+        ]
+
+    def estimate_complexity(self, artifact):
+        try:
+            if hasattr(artifact, 'get_size_estimate'):
+                return artifact.get_size_estimate()
+        except Exception as e:
+            self.logger.warning(f"Failed to estimate complexity for {artifact}: {e}")
+        return 1  # default
+
+    def prioritize_tasks(self, artifacts):
+        queue = asyncio.PriorityQueue()
+        for artifact in artifacts:
+            complexity = self.estimate_complexity(artifact)
+            # we invert the complexity to ensure higher complexity -> higher priority
+            # if you want high complexity first, store negative complexity in the priority queue
+            # or if the smaller number means earlier processing, just keep as is
+            queue.put_nowait(PrioritizedItem(complexity, artifact))
+        return queue
+
+    async def resource_monitor(self, queue, workers):
+        """Monitor system resources and adjust worker count while queue is not empty."""
+        while True:
+            # break if queue done
+            if queue.empty():
+                await asyncio.sleep(0.5)
+                if queue.empty():
+                    break
+
+            try:
+                available_memory = psutil.virtual_memory().available
+                worker_memory_bytes = self.memory_per_worker_gb * (1024 ** 3)
+                max_workers_by_memory = available_memory // worker_memory_bytes
+
+                # figure out how many workers we can sustain
+                # note: we also cap by self.max_workers
+                optimal_workers = min(psutil.cpu_count(), max_workers_by_memory, self.max_workers)
+
+                # ensure at least self.min_workers is used
+                optimal_workers = max(self.min_workers, optimal_workers)
+
+                current_worker_count = len(workers)
+
+                if optimal_workers > current_worker_count:
+                    # we can add more workers if queue is not empty
+                    diff = optimal_workers - current_worker_count
+                    for _ in range(diff):
+                        worker_id = len(workers)
+                        # create a new worker
+                        w = asyncio.create_task(self.worker(queue, worker_id))
+                        workers.append(w)
+                        self.logger.info(f"Added worker {worker_id}. Total workers: {len(workers)}")
+                elif optimal_workers < current_worker_count:
+                    # remove some workers
+                    diff = current_worker_count - optimal_workers
+                    for _ in range(diff):
+                        w = workers.pop()
+                        w.cancel()
+                        self.logger.info(f"Removed a worker. Total workers: {len(workers)}")
+
+                await asyncio.sleep(self.monitor_interval)
+
+            except asyncio.CancelledError:
+                # monitor is being shut down
+                break
+            except Exception as e:
+                self.logger.error(f"Error in resource_monitor: {e}")
+                await asyncio.sleep(self.monitor_interval)
+
+    @asynccontextmanager
+    async def artifact_lock(self, artifact):
+        lock = self.get_lock_for_artifact(artifact)
+        try:
+            await asyncio.wait_for(lock.acquire(), timeout=self.lock_acquire_timeout_seconds)
+            yield
+        except asyncio.TimeoutError:
+            self.logger.error(f"Timeout acquiring lock for artifact: {artifact.__class__.__name__}")
+            yield  # continue but no actual lock was acquired
+        finally:
+            if lock.locked():
+                lock.release()
+
+    async def async_update_artifact(self, artifact, **kwargs):
+        for attempt in range(self.retry_attempts):
+            try:
+                async with self.artifact_lock(artifact):
+                    self.logger.info(
+                        f"Updating artifact: {artifact.__class__.__name__}, Attempt: {attempt + 1} of {self.retry_attempts}" )
+                    start_time = time.time()
+                    await asyncio.wait_for(
+                        asyncio.to_thread(artifact.update_parquet, **kwargs),
+                        timeout=self.update_timeout_seconds
+                    )
+                    elapsed_time = time.time() - start_time
+                    self.logger.info(
+                        f"Successfully updated artifact: {artifact.__class__.__name__} in {elapsed_time:.2f}s." )
+                    return
+
+            except asyncio.TimeoutError:
+                self.logger.error(f"Timeout updating artifact {artifact.__class__.__name__}, Attempt: {attempt + 1}")
+            except Exception as e:
+                self.logger.error(
+                    f"Error updating artifact {artifact.__class__.__name__}, Attempt: {attempt + 1}: {e}" )
+
+            # exponential backoff
+            await asyncio.sleep(2 ** attempt)
+
+        self.logger.error(f"All retry attempts failed for artifact: {artifact.__class__.__name__}")
+
+    async def worker(self, queue, worker_id, **kwargs):
+        """A worker that dynamically pulls tasks from the queue."""
+        while True:
+            try:
+                prioritized_item = await queue.get()
+                if prioritized_item is None:
+                    break
+                artifact = prioritized_item.artifact
+                # heartbeat
+                self.worker_heartbeat[worker_id] = time.time()
+
+                await self.async_update_artifact(artifact, **kwargs)
+
+            except asyncio.CancelledError:
+                self.logger.info(f"Worker {worker_id} shutting down gracefully.")
+                break
+            except Exception as e:
+                self.logger.error(f"Error in worker {worker_id}: {e}")
+            finally:
+                queue.task_done()
+
+    async def process_tasks(self, queue, initial_workers, **kwargs):
+        """Start a set of workers and a resource monitor to dynamically adjust them."""
+        # create initial workers
+        workers = []
+        for worker_id in range(initial_workers):
+            w = asyncio.create_task(self.worker(queue, worker_id, **kwargs))
+            workers.append(w)
+
+        # start resource monitor
+        monitor_task = asyncio.create_task(self.resource_monitor(queue, workers))
+
+        # wait until queue is done
+        try:
+            await queue.join()
+        finally:
+            # cancel resource monitor
+            monitor_task.cancel()
+            # all workers done
+            for w in workers:
+                w.cancel()
+            await asyncio.gather(*workers, return_exceptions=True)
+
+    async def update_data(self, data_type, **kwargs):
+        self.logger.info(f"Processing wrapper group: {data_type} with {kwargs}")
+        artifacts = self.get_artifacts(data_type)
+        queue = self.prioritize_tasks(artifacts)
+
+        # compute initial worker count (this can be low if memory is low initially)
+        initial_workers = self.calculate_initial_workers(len(artifacts))
+        self.logger.info(f"Initial worker count: {initial_workers} for {len(artifacts)} artifacts")
+
+        total_start_time = time.time()
+        await self.process_tasks(queue, initial_workers, **kwargs)
+        total_time = time.time() - total_start_time
+        self.logger.info(f"Total processing time: {total_time:.2f} seconds.")
+
+    def calculate_initial_workers(self, artifact_count: int) -> int:
+        """Compute the initial number of workers before resource_monitor can adjust."""
+        self.logger.info("Calculating initial worker count...")
+        available_memory = psutil.virtual_memory().available
+        self.logger.info(f"Available memory: {available_memory / (1024 ** 3):.2f} GB")
+        worker_memory_bytes = self.memory_per_worker_gb * (1024 ** 3)
+        self.logger.info(f"Memory per worker: {worker_memory_bytes / (1024 ** 3):.2f} GB")
+        max_workers_by_memory = available_memory // worker_memory_bytes
+        self.logger.info(f"Max workers by memory: {max_workers_by_memory}")
+        # also consider CPU count and artifact_count
+        initial = min(psutil.cpu_count(), max_workers_by_memory, artifact_count, self.max_workers)
+        self.logger.info(f"Optimal workers: {initial} CPU: {psutil.cpu_count()} Max Workers: {self.max_workers}")
+        return max(self.min_workers, initial)
+

sibi_dst/df_helper/_df_helper.py

@@ -112,6 +112,7 @@ class DfHelper:
         :return: None
         """
         self.logger.debug(f"backend used: {self.backend}")
+        self.logger.debug(f"kwargs passed to backend plugins: {kwargs}")
         self._backend_query = self.__get_config(QueryConfig, kwargs)
         self._backend_params = self.__get_config(ParamsConfig, kwargs)
         if self.backend == 'django_db':
@@ -124,8 +125,8 @@ class DfHelper:
         elif self.backend == 'sqlalchemy':
             self.backend_sqlalchemy = self.__get_config(SqlAlchemyConnectionConfig, kwargs)
 
-    @staticmethod
-    def __get_config(model: [T], kwargs: Dict[str, Any]) -> Union[T]:
+
+    def __get_config(self, model: [T], kwargs: Dict[str, Any]) -> Union[T]:
         """
         Initializes a Pydantic model with the keys it recognizes from the kwargs,
         and removes those keys from the kwargs dictionary.
@@ -135,7 +136,9 @@ class DfHelper:
         """
         # Extract keys that the model can accept
         recognized_keys = set(model.__annotations__.keys())
+        self.logger.debug(f"recognized keys: {recognized_keys}")
         model_kwargs = {k: kwargs.pop(k) for k in list(kwargs.keys()) if k in recognized_keys}
+        self.logger.debug(f"model_kwargs: {model_kwargs}")
         return model(**model_kwargs)
 
     def load_parallel(self, **options):

sibi_dst/df_helper/_parquet_artifact.py

@@ -1,11 +1,11 @@
+import logging
 from typing import Optional, Any, Dict
 
 import dask.dataframe as dd
 import fsspec
 
 from sibi_dst.df_helper import DfHelper
-from sibi_dst.utils import DataWrapper
-from sibi_dst.utils import DateUtils
+from sibi_dst.utils import DataWrapper, DateUtils, Logger
 
 
 class ParquetArtifact(DfHelper):
@@ -82,7 +82,12 @@ class ParquetArtifact(DfHelper):
             **kwargs,
         }
         self.df: Optional[dd.DataFrame] = None
+        self.debug = self.config.setdefault('debug', False)
+        self.logger = self.config.setdefault('logger',Logger.default_logger(logger_name=f'parquet_artifact_{__class__.__name__}'))
+        self.logger.set_level(logging.DEBUG if self.debug else logging.INFO)
         self.data_wrapper_class = data_wrapper_class
+        self.class_params = self.config.setdefault('class_params', None)
+        self.load_params = self.config.setdefault('load_params', None)
         self.date_field = self.config.setdefault('date_field', None)
         if self.date_field is None:
             raise ValueError('date_field must be set')
@@ -150,6 +155,7 @@ class ParquetArtifact(DfHelper):
 
     def _prepare_params(self, kwargs: Dict[str, Any]) -> Dict[str, Any]:
         """Prepare the parameters for generating the Parquet file."""
+        kwargs = {**self.config, **kwargs}
         return {
             'class_params': kwargs.pop('class_params', None),
             'date_field': kwargs.pop('date_field', self.date_field),

sibi_dst/df_helper/_parquet_reader.py

@@ -1,10 +1,11 @@
+import logging
 from typing import Optional
 
 import dask.dataframe as dd
 import fsspec
 
 from sibi_dst.df_helper import DfHelper
-
+from sibi_dst.utils import Logger
 
 class ParquetReader(DfHelper):
     """
@@ -53,6 +54,9 @@ class ParquetReader(DfHelper):
             **kwargs,
         }
         self.df: Optional[dd.DataFrame] = None
+        self.debug = self.config.setdefault('debug', False)
+        self.logger = self.config.setdefault('logger', Logger.default_logger(logger_name=self.__class__.__name__))
+        self.logger.set_level(logging.DEBUG if self.debug else logging.INFO)
         self.parquet_storage_path = self.config.setdefault('parquet_storage_path', None)
         if self.parquet_storage_path is None:
             raise ValueError('parquet_storage_path must be set')

sibi_dst/df_helper/backends/sqlalchemy/_db_connection.py

@@ -63,3 +63,4 @@ class SqlAlchemyConnectionConfig(BaseModel):
                 connection.execute(text("SELECT 1"))
         except OperationalError as e:
             raise ValueError(f"Failed to connect to the database: {e}")
+

sibi_dst/osmnx_helper/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from .base_osm_map import BaseOsmMap
-from .utils import PBFHandler
+from .v1.base_osm_map import BaseOsmMap
+from .v1.utils import PBFHandler
 
 __all__ = [
     "BaseOsmMap",

sibi_dst/osmnx_helper/{basemaps → v1/basemaps}/router_plotter.py

@@ -1,20 +1,21 @@
 from __future__ import annotations
-from sibi_dst.osmnx_helper.utils import get_distance_between_points, add_arrows
+from sibi_dst.osmnx_helper.v1.utils import get_distance_between_points, add_arrows
 from collections import defaultdict
 import folium
 from folium.plugins import AntPath
 import networkx as nx
 
 from sibi_dst.osmnx_helper import BaseOsmMap
-from sibi_dst.osmnx_helper.basemaps.calendar_html import calendar_html
+from sibi_dst.osmnx_helper.v1.basemaps.calendar_html import calendar_html
 
 class RoutePlotter(BaseOsmMap):
     def __init__(self, osmnx_graph, df, **kwargs):
         self.action_field = kwargs.pop('action_field', '')
         self.action_groups = kwargs.pop('action_groups', {})
         self.action_styles = kwargs.pop('action_styles', {})
-        self.use_ant_path = kwargs.pop('use_ant_path', True)
-        self.show_calendar = kwargs.pop('show_calendar', True)
+        self.use_ant_path = kwargs.pop('use_ant_path', False)
+        self.show_calendar = kwargs.pop('show_calendar', False)
+        self.show_order_markers = kwargs.pop('show_order_markers', False)
         self.show_map_title = kwargs.pop('show_map_title', True)
         self.sort_keys = kwargs.pop('sort_keys', None)
         self.main_route_layer = folium.FeatureGroup(name="Main Route")
@@ -24,6 +25,8 @@ class RoutePlotter(BaseOsmMap):
         self.actions = []
         self.action_group_counts = {action_group: 0 for action_group in self.action_groups}
         self.marker_count = 1
+        # Add a snapping threshold (in meters) to avoid drawing nodes/markers that are too close.
+        self.snap_distance = kwargs.pop('snap_distance', 30)
         kwargs.update({'calc_nearest_nodes': True})
         kwargs['dt_field'] = 'date_time'
         super().__init__(osmnx_graph, df, **kwargs)
@@ -36,6 +39,8 @@ class RoutePlotter(BaseOsmMap):
         self._calculate_routes()
         self._plot_routes()
         self._add_markers()
+        if self.show_order_markers:
+            self._add_order_markers()
         self.main_route_layer.add_to(self.osm_map)
         if self.show_calendar:
             self._add_calendar()
@@ -57,8 +62,8 @@ class RoutePlotter(BaseOsmMap):
                 self.route_polylines.append((polyline, color))
                 for action_group, action_markers in markers.items():
                     self.markers[action_group].extend(action_markers)
-                    self.action_group_counts[action_group] += 1
-                    self.marker_count += 1
+                    self.action_group_counts[action_group] += len(action_markers)
+                    self.marker_count += len(action_markers)
         if self.verbose:
             print("Route and marker calculation complete.")
 
@@ -70,7 +75,7 @@ class RoutePlotter(BaseOsmMap):
 
     def _calculate_route(self, i):
         if self.verbose:
-            print(f"Calculating for item:{i}")
+            print(f"Calculating for item: {i}")
         orig = self.nearest_nodes[i]
         dest = self.nearest_nodes[i + 1]
         try:
@@ -81,17 +86,31 @@ class RoutePlotter(BaseOsmMap):
             lats, lons = zip(*[(self.G.nodes[node]['y'] + offset, self.G.nodes[node]['x']) for node in route])
             color = 'blue' if i < self.max_distance_index else 'red'
             polyline = list(zip(lats, lons))
+            # Apply node snapping to the polyline to remove points that are too close.
+            polyline = self._snap_polyline(polyline)
             markers = self._calculate_markers(i)
             return polyline, color, markers
         except nx.NetworkXNoPath:
             if self.verbose:
-                print(f"Item:{i}-No path found for {orig} to {dest}")
+                print(f"Item: {i} - No path found for {orig} to {dest}")
             return None, None, {}
         except nx.NodeNotFound:
             if self.verbose:
-                print(f"Item:{i}-No path found for {orig} to {dest}")
+                print(f"Item: {i} - No path found for {orig} to {dest}")
             return None, None, {}
 
+    def _snap_polyline(self, polyline: list[tuple[float, float]]) -> list[tuple[float, float]]:
+        """
+        Returns a filtered polyline where consecutive points closer than snap_distance are removed.
+        """
+        if not polyline:
+            return polyline
+        snapped_polyline = [polyline[0]]
+        for point in polyline[1:]:
+            if get_distance_between_points(snapped_polyline[-1], point, 'm') >= self.snap_distance:
+                snapped_polyline.append(point)
+        return snapped_polyline
+
     def _calculate_markers(self, i):
         # Calculate markers for action groups
         markers = defaultdict(list)
@@ -110,24 +129,26 @@ class RoutePlotter(BaseOsmMap):
     def _plot_routes(self):
         if self.verbose:
             print("Plotting routes and markers...")
-        # self.action_group_counts = {action_group: 0 for action_group in self.feature_groups.keys()}
         for polyline, color in self.route_polylines:
             if self.use_ant_path:
                 AntPath(
                     locations=polyline,
                     color=color,
-                    weight=3,  # Increase line thickness
-                    opacity=10,  # Increase opacity
-                    # pulse_color=color,
-                    delay=1000,  # Slower animation to reduce flickering
-                    # dash_array=[20, 30]  # Adjust dash pattern if needed
+                    weight=3,       # Increased line thickness
+                    opacity=10,     # Increased opacity
+                    delay=1000,     # Slower animation to reduce flickering
                 ).add_to(self.main_route_layer)
             else:
                 folium.PolyLine(locations=polyline, color=color).add_to(self.main_route_layer)
                 self.osm_map = add_arrows(self.osm_map, polyline, color, n_arrows=3)
-        # Plot markers for action groups
+        # Plot markers for action groups with snapping to avoid drawing too many nearby markers.
         for action_group, action_markers in self.markers.items():
+            seen_positions = []
             for location, tooltip, popup_data, action_style in action_markers:
+                # Skip marker if a nearby marker (within snap_distance) has already been added.
+                if any(get_distance_between_points(location, pos, 'm') < self.snap_distance for pos in seen_positions):
+                    continue
+                seen_positions.append(location)
                 folium.Marker(
                     location=location,
                     popup=folium.Popup(popup_data, max_width=600),
@@ -145,11 +166,14 @@ class RoutePlotter(BaseOsmMap):
     def _add_markers(self):
         if self.verbose:
             print("Adding markers...")
-        # Add start marker
+        # Add a start marker
         start_popup = folium.Popup(f"Start of route at {self.dt[0]}", max_width=300)
-        folium.Marker(location=self.gps_points[0], popup=start_popup,
-                      icon=folium.Icon(icon='flag-checkered', prefix='fa')).add_to(self.osm_map)
-        # Add total distance marker at the end
+        folium.Marker(
+            location=self.gps_points[0],
+            popup=start_popup,
+            icon=folium.Icon(icon='flag-checkered', prefix='fa')
+        ).add_to(self.osm_map)
+        # Add an end marker with total distance info
         folium.Marker(
             self.gps_points[-1],
             popup=f"End of Route at {self.dt[self.max_time_index]}. Total Distance Travelled: {self.total_distance / 1000:.2f} km",
@@ -165,15 +189,15 @@ class RoutePlotter(BaseOsmMap):
     def _add_map_title(self):
         if self.map_html_title and self.show_map_title:
             title_html = f'''
-                 <div style="position: fixed; 
-                             top: 10px; 
-                             left: 50%; 
+                 <div style="position: fixed;
+                             top: 10px;
+                             left: 50%;
                              transform: translate(-50%, 0%);
-                             z-index: 9999; 
-                             font-size: 24px; 
-                             font-weight: bold; 
-                             background-color: white; 
-                             padding: 10px; 
+                             z-index: 9999;
+                             font-size: 24px;
+                             font-weight: bold;
+                             background-color: white;
+                             padding: 10px;
                              border: 2px solid black;
                              border-radius: 5px;">
                     {self.map_html_title}
@@ -181,6 +205,37 @@ class RoutePlotter(BaseOsmMap):
                  '''
             self.osm_map.get_root().html.add_child(folium.Element(title_html))
 
+    def _add_order_markers(self):
+        """Adds numbered markers to indicate the visit order."""
+        order_feature_group = folium.FeatureGroup(name="Visit Order")
+        for idx, location in enumerate(self.gps_points):
+            # Create a DivIcon with the number (starting at 1)
+            icon = folium.DivIcon(
+                icon_size=(24, 24),
+                icon_anchor=(12, 12),
+                html=f'''
+                    <div style="
+                        font-size: 12pt;
+                        color: black;
+                        background-color: white;
+                        border: 1px solid black;
+                        border-radius: 50%;
+                        width: 24px;
+                        height: 24px;
+                        text-align: center;
+                        line-height: 24px;">
+                        {idx + 1}
+                    </div>
+                '''
+            )
+            folium.Marker(
+                location=location,
+                icon=icon,
+                tooltip=f"GPS Set No. {idx + 1}: {self.dt[idx]}"
+            ).add_to(order_feature_group)
+
+        order_feature_group.add_to(self.osm_map)
+
     def _get_data(self, index):
-        # implement in subclass to populate popups
-        ...
+        # Implement in subclass to populate popups
+        ...