sibi-dst 2025.1.11__tar.gz → 2025.1.13__tar.gz

{sibi_dst-2025.1.11 → sibi_dst-2025.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sibi-dst
-Version: 2025.1.11
+Version: 2025.1.13
 Summary: Data Science Toolkit
 Author: Luis Valverde
 Author-email: lvalverdeb@gmail.com

{sibi_dst-2025.1.11 → sibi_dst-2025.1.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sibi-dst"
-version = "2025.1.11"
+version = "2025.1.13"
 description = "Data Science Toolkit"
 authors = ["Luis Valverde <lvalverdeb@gmail.com>"]
 readme = "README.md"
@@ -48,6 +48,8 @@ osmnx = "^2.0.5"
 geopy = "^2.4.1"
 folium = "^0.20.0"
 geopandas = "^1.1.1"
+networkx = "^3.5"
+scikit-learn = "^1.7.1"
 
 
 [tool.poetry.group.loggers.dependencies]

{sibi_dst-2025.1.11 → sibi_dst-2025.1.13}/sibi_dst/osmnx_helper/__init__.py

@@ -2,5 +2,6 @@ from .base_osm_map import BaseOsmMap
 from .utils import PBFHandler
 __all__ = [
     "BaseOsmMap",
+    #"MapConfig",
     "PBFHandler",
 ]

sibi_dst-2025.1.13/sibi_dst/osmnx_helper/basemaps/route_map_plotter.py

@@ -0,0 +1,203 @@
+import folium
+import math
+import networkx as nx
+import pandas as pd
+from datetime import datetime
+from folium.plugins import AntPath, PolyLineTextPath
+from geopy.distance import geodesic
+from pydantic import BaseModel, Field
+from typing import Optional, Dict, List, Tuple
+
+def get_default_action_colors() -> Dict[str, str]:
+    """Provides a default dictionary for action colors."""
+    return {
+        "Reporte Posición": "blue", "Acceso o Salida": "lightblue",
+        "Producto para Reintentar": "orange", "Formalización iniciada": "purple",
+        "Producto Formalizado": "green", "Esfuerzo Registrado": "darkblue",
+        "Abandona Formalización": "lightred", "Producto Rechazado": "red",
+        "Producto Devuelto": "darkred",
+    }
+
+class RouteMapPlotterSettings(BaseModel):
+    """Manages all configuration settings for the RouteMapPlotter."""
+    use_antpath: bool = Field(True, description="If True, use animated AntPath; otherwise, use a static PolyLine.")
+    zoom_start: int = Field(14, description="Initial zoom level for the map.")
+    forward_color: str = Field("blue", description="Color for the outbound portion of the route.")
+    return_color: str = Field("red", description="Color for the return portion of the route.")
+    return_offset_m: float = Field(2.5, description="Meters to offset the return path for visibility.")
+    antpath_delay: int = Field(800, description="Delay in ms for the AntPath animation.")
+    antpath_weight: int = Field(5, description="Weight of the AntPath line.")
+    antpath_dash_array: List[int] = Field(default=[10, 20], description="Dash pattern for the AntPath.")
+    antpath_pulse_color: str = Field("white", description="Pulse color for the AntPath animation.")
+    marker_origin_color: str = Field("green", description="Color for the start marker.")
+    marker_end_color: str = Field("red", description="Color for the finish marker.")
+    furthest_marker_color: str = Field("orange", description="Color for the furthest point marker.")
+    arrow_color: str = Field("black", description="Color for direction arrows on static PolyLines.")
+    marker_radius: int = Field(6, description="Radius of the event circle markers.")
+    default_tile: str = Field("OpenStreetMap", description="The default map tile layer to display.")
+    arrow_spacing: int = Field(75, description="Spacing in pixels between arrows on static PolyLines.")
+    action_colors: Dict[str, str] = Field(default_factory=get_default_action_colors)
+    date_field: str = Field("date_time", description="Name of the date/time field in the DataFrame.")
+    lat_col: str = Field("latitude", description="Name of the latitude field in the DataFrame.")
+    lon_col: str = Field("longitude", description="Name of the longitude field in the DataFrame.")
+
+class RouteDataPoint(BaseModel):
+    """Defines the data schema for a single row in the input DataFrame."""
+    latitude: float
+    longitude: float
+    date_time: datetime
+    origin_node: int
+    dest_node: int
+    path_nodes: List[int]
+    action: Optional[str] = None
+
+class RouteMapPlotter:
+    def __init__(
+        self,
+        graph: nx.Graph,
+        settings: Optional[RouteMapPlotterSettings] = None,
+    ):
+        if not isinstance(graph, nx.Graph) or not graph.nodes:
+            raise ValueError("A valid NetworkX graph with nodes is required.")
+        self.graph = graph
+        self.settings = settings or RouteMapPlotterSettings()
+        self.tile_layers = {
+            "OpenStreetMap": "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+            #"CartoDB Positron": "https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png",
+            #"CartoDB Dark Matter": "https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png",
+        }
+
+    def _compute_distance_time_metrics(self, df: pd.DataFrame) -> pd.DataFrame:
+        df = df.copy().sort_values(self.settings.date_field).reset_index(drop=True)
+        df[self.settings.date_field] = pd.to_datetime(df[self.settings.date_field])
+        df["prev_lat"] = df[self.settings.lat_col].shift(1)
+        df["prev_lon"] = df[self.settings.lon_col].shift(1)
+        df["prev_time"] = df[self.settings.date_field].shift(1)
+
+        valid_points = df["prev_lat"].notna()
+        df.loc[valid_points, "distance_to_prev"] = df[valid_points].apply(
+            lambda r: geodesic((r["prev_lat"], r["prev_lon"]), (r["latitude"], r["longitude"])).meters, axis=1
+        )
+        df["time_elapsed"] = df[self.settings.date_field] - df["prev_time"]
+        df["cumulative_time"] = df["time_elapsed"].cumsum()
+        df.fillna({"distance_to_prev": 0.0, "time_elapsed": pd.Timedelta(0)}, inplace=True)
+        return df.drop(columns=["prev_lat", "prev_lon", "prev_time"])
+
+    def _format_timedelta(self, td: pd.Timedelta) -> str:
+        total_seconds = int(td.total_seconds())
+        hours, remainder = divmod(total_seconds, 3600)
+        minutes, seconds = divmod(remainder, 60)
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+    def _get_midpoint(self, df: pd.DataFrame) -> Tuple[float, float]:
+        all_nodes = [node for path in df["path_nodes"] if path for node in path]
+        if not all_nodes:
+            return (df[self.settings.lat_col].mean(), df[self.settings.lon_col].mean())
+        avg_lat = sum(self.graph.nodes[n]["y"] for n in all_nodes) / len(all_nodes)
+        avg_lon = sum(self.graph.nodes[n]["x"] for n in all_nodes) / len(all_nodes)
+        return (avg_lat, avg_lon)
+
+    def _offset_coordinates(self, coords: List[Tuple[float, float]], offset_m: float) -> List[Tuple[float, float]]:
+        if len(coords) < 2 or offset_m == 0: return coords
+        offset_coords = []
+        for i, (lat, lon) in enumerate(coords):
+            if i == 0: p_prev, p_next = coords[i], coords[i + 1]
+            elif i == len(coords) - 1: p_prev, p_next = coords[i - 1], coords[i]
+            else: p_prev, p_next = coords[i - 1], coords[i + 1]
+            normal_angle = math.atan2(p_next[0] - p_prev[0], p_next[1] - p_prev[1]) + math.pi / 2
+            offset_lat = offset_m / 111111
+            offset_lon = offset_m / (111111 * math.cos(math.radians(lat)))
+            new_lat = lat + offset_lat * math.sin(normal_angle)
+            new_lon = lon + offset_lon * math.cos(normal_angle)
+            offset_coords.append((new_lat, new_lon))
+        return offset_coords
+
+    def _find_furthest_point(self, df: pd.DataFrame) -> Tuple[Optional[int], Optional[int], Optional[pd.Series]]:
+        if df["origin_node"].isnull().all(): return None, None, None
+        start_node = df["origin_node"].iloc[0]
+        start_lat, start_lon = self.graph.nodes[start_node]["y"], self.graph.nodes[start_node]["x"]
+        max_dist, furthest_node, furthest_idx, furthest_row = -1, None, None, None
+        for idx, row in df.iterrows():
+            if not row["path_nodes"]: continue
+            for n in row["path_nodes"]:
+                lat, lon = self.graph.nodes[n]["y"], self.graph.nodes[n]["x"]
+                dist = geodesic((start_lat, start_lon), (lat, lon)).meters
+                if dist > max_dist:
+                    max_dist, furthest_node, furthest_idx, furthest_row = dist, n, idx, row
+        return furthest_node, furthest_idx, furthest_row
+
+    def _plot_path(self, m: folium.Map, coords: List[Tuple[float, float]], color: str):
+        if self.settings.use_antpath:
+            AntPath(locations=coords, color=color, weight=self.settings.antpath_weight,
+                    delay=self.settings.antpath_delay, dash_array=self.settings.antpath_dash_array,
+                    pulse_color=self.settings.antpath_pulse_color, opacity=0.8).add_to(m)
+        else:
+            polyline = folium.PolyLine(coords, color=color, weight=4, opacity=0.6).add_to(m)
+            PolyLineTextPath(polyline, "▶", repeat=True, offset=8, spacing=self.settings.arrow_spacing,
+                             attributes={"fill": self.settings.arrow_color, "font-weight": "bold"}).add_to(m)
+
+    def _add_flag_marker(self, m: folium.Map, lat: float, lon: float, color: str, tooltip: str):
+        icon = folium.Icon(color=color, icon="flag", prefix="fa")
+        folium.Marker(location=(lat, lon), icon=icon, tooltip=tooltip).add_to(m)
+
+    def _add_point_markers(self, m: folium.Map, df: pd.DataFrame):
+        action_colors = self.settings.action_colors
+        action_layers = {action: folium.FeatureGroup(name=action) for action in action_colors}
+        action_layers["Others"] = folium.FeatureGroup(name="Others")
+        for idx, row in df.iterrows():
+            action = row.get("action", "Unknown")
+            tooltip = (f"<b>#{idx + 1} {action}</b><br>"
+                       f"Time: {row['date_time'].strftime('%H:%M:%S')}<br>"
+                       f"Dist from prev: {row['distance_to_prev']:.1f} m<br>"
+                       f"Time since prev: {self._format_timedelta(row['time_elapsed'])}")
+            color = action_colors.get(action, "gray")
+            target_layer = action_layers.get(action, action_layers["Others"])
+            folium.CircleMarker(location=(row[self.settings.lat_col], row[self.settings.lon_col]), radius=self.settings.marker_radius,
+                                color=color, fill=True, fill_opacity=0.9, tooltip=tooltip).add_to(target_layer)
+        for layer in action_layers.values(): layer.add_to(m)
+
+    # --- MAIN PLOT METHOD ---
+
+    def plot(self, df: pd.DataFrame) -> folium.Map:
+        try:
+            df_dict = df.iloc[0].to_dict()
+            df_dict[self.settings.date_field] = pd.to_datetime(df_dict[self.settings.date_field])
+            RouteDataPoint.model_validate(df_dict)
+        except Exception as e:
+            raise ValueError(f"DataFrame does not match required schema. Error: {e}")
+
+        processed_df = self._compute_distance_time_metrics(df)
+        midpoint = self._get_midpoint(processed_df)
+
+        m = folium.Map(location=midpoint, zoom_start=self.settings.zoom_start,
+                       tiles=self.settings.default_tile)
+        for name, url in self.tile_layers.items():
+            if name != self.settings.default_tile:
+                folium.TileLayer(tiles=url, name=name, attr=name).add_to(m)
+
+        furthest_node, furthest_idx, furthest_row = self._find_furthest_point(processed_df)
+
+        if furthest_idx is not None:
+            for idx, row in processed_df.iterrows():
+                if not row["path_nodes"]: continue
+                coords = [(self.graph.nodes[n]["y"], self.graph.nodes[n]["x"]) for n in row["path_nodes"]]
+                is_forward = idx <= furthest_idx
+                path_color = self.settings.forward_color if is_forward else self.settings.return_color
+                path_coords = coords if is_forward else self._offset_coordinates(coords, self.settings.return_offset_m)
+                self._plot_path(m, path_coords, path_color)
+
+        start_node = processed_df["origin_node"].iloc[0]
+        self._add_flag_marker(m, self.graph.nodes[start_node]["y"], self.graph.nodes[start_node]["x"],
+                              self.settings.marker_origin_color, f"Start<br>{processed_df[self.settings.date_field].iloc[0].strftime('%H:%M:%S')}")
+
+        end_node = processed_df["dest_node"].iloc[-1]
+        self._add_flag_marker(m, self.graph.nodes[end_node]["y"], self.graph.nodes[end_node]["x"],
+                              self.settings.marker_end_color, f"Finish<br>{processed_df[self.settings.date_field].iloc[-1].strftime('%H:%M:%S')}")
+
+        if furthest_node:
+            self._add_flag_marker(m, self.graph.nodes[furthest_node]["y"], self.graph.nodes[furthest_node]["x"],
+                                  self.settings.furthest_marker_color, f"Furthest Point<br>{furthest_row[self.settings.date_field].strftime('%H:%M:%S')}")
+
+        self._add_point_markers(m, processed_df)
+        folium.LayerControl(collapsed=False).add_to(m)
+        return m

sibi_dst-2025.1.13/sibi_dst/osmnx_helper/route_path_builder.py

@@ -0,0 +1,98 @@
+import numpy as np
+import pandas as pd
+import networkx as nx
+import osmnx as ox
+from typing import List
+
+class RoutePathBuilder:
+    """
+    Builds shortest paths for consecutive GPS points (origins & destinations) within each associate's track.
+    """
+
+    def __init__(
+        self,
+        graph: nx.MultiDiGraph,
+        lat_col: str = "latitude",
+        lon_col: str = "longitude",
+        grouping_col: str = "associate_id",
+        sort_key=None  # Default sort key for DataFrame
+    ):
+        """
+        :param graph: The OSMnx MultiDiGraph.
+        :param lat_col: Column name for latitude.
+        :param lon_col: Column name for longitude.
+        :param associate_col: Column name for associate/grouping key.
+        """
+        if sort_key is None:
+            sort_key = ["associate_id", "date_time"]
+        self.graph = graph
+        self.lat_col = lat_col
+        self.lon_col = lon_col
+        self.grouping_col = grouping_col
+        self.sort_key = sort_key
+        if self.sort_key is None:
+            self.sort_key = [self.grouping_col, "date_time"]
+
+    @staticmethod
+    def _get_shortest_path(u: int, v: int, graph: nx.MultiDiGraph) -> List[int]:
+        """Return the node sequence for the shortest path from u to v, or [] if none."""
+        try:
+            return nx.shortest_path(graph, u, v, weight="length")
+        except nx.NetworkXNoPath:
+            return []
+
+    @staticmethod
+    def _path_length_from_nodes(node_list: List[int], graph: nx.MultiDiGraph) -> float:
+        """Sum up the 'length' attribute along consecutive node pairs."""
+        if len(node_list) < 2:
+            return np.nan
+        total = 0.0
+        for u, v in zip(node_list[:-1], node_list[1:]):
+            edge_data = graph.get_edge_data(u, v)
+            lengths = [edata.get("length", 0) for edata in edge_data.values()]
+            total += min(lengths) if lengths else 0
+        return total
+
+    def build_routes(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Generate destination coordinates, snap to graph nodes, and compute shortest paths.
+
+        :param df: Input DataFrame containing grouping_col, latitude, and longitude columns.
+        :return: DataFrame with added columns:
+            ['dest_lat', 'dest_lon', 'origin_node', 'dest_node', 'path_nodes', 'path_coords', 'distance_m']
+        """
+        # 1) Build destination coordinates by shifting per grouping column
+        df = df.copy()
+        df["dest_lat"] = df.groupby(self.grouping_col)[self.lat_col].shift(-1)
+        df["dest_lon"] = df.groupby(self.grouping_col)[self.lon_col].shift(-1)
+
+        # Drop tail rows without next point
+        df = df.dropna(subset=["dest_lat", "dest_lon"]).reset_index(drop=True)
+
+        # 2) Snap origin & destination points to graph nodes
+        df["origin_node"] = ox.nearest_nodes(
+            self.graph, X=df[self.lon_col].values, Y=df[self.lat_col].values
+        )
+        df["dest_node"] = ox.nearest_nodes(
+            self.graph, X=df["dest_lon"].values, Y=df["dest_lat"].values
+        )
+
+        # 3) Compute paths, coordinates, and distances
+        df["path_nodes"] = [
+            self._get_shortest_path(u, v, self.graph)
+            for u, v in zip(df["origin_node"], df["dest_node"])
+        ]
+
+        df["path_coords"] = df["path_nodes"].apply(
+            lambda nl: [(self.graph.nodes[n]["y"], self.graph.nodes[n]["x"]) for n in nl]
+        )
+
+        df["distance_m"] = df["path_nodes"].apply(
+            lambda nl: self._path_length_from_nodes(nl, self.graph)
+        )
+        # Ensure NaN distances become 0
+        df["distance_m"] = df["distance_m"].fillna(0)
+        # Remove any legs with no path
+        df = df[df["path_nodes"].str.len() > 0].reset_index(drop=True)
+
+        return df.sort_values(self.sort_key).reset_index(drop=True)

{sibi_dst-2025.1.11 → sibi_dst-2025.1.13}/sibi_dst/osmnx_helper/utils.py

@@ -442,6 +442,8 @@ def get_graph(**options):
              - The list or collection of edges that describe relationships
                between nodes in the graph
     """
+    if not options:
+        raise ValueError("No options provided to PBFHandler for graph creation.")
     handler = PBFHandler(**options)
     handler.load()
     return handler.graph, handler.nodes, handler.edges

{sibi_dst-2025.1.11 → sibi_dst-2025.1.13}/sibi_dst/utils/date_utils.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import datetime
 from typing import Union, Tuple, Callable, Dict, Optional
 
@@ -306,64 +308,62 @@ class FileAgeChecker:
 
 
 # --- Vectorized Helper Functions ---
-# These replace the slow, row-by-row .apply() logic. They operate
-# on entire DataFrame partitions for maximum efficiency.
-
-def _vectorized_busday_count(
-        partition: pd.DataFrame,
-        begin_col: str,
-        end_col: str,
-        holidays: list
-) -> pd.Series:
-    """Vectorized function to count business days on a DataFrame partition."""
-    if partition.empty:
-        return pd.Series([], dtype=float)
-
-    # Convert entire columns to datetime at once, coercing errors to NaT
-    start_dates = pd.to_datetime(partition[begin_col], errors='coerce').dt.date
-    end_dates = pd.to_datetime(partition[end_col], errors='coerce').dt.date
-
-    # Create a result series filled with NaN to handle rows with invalid dates
-    result = pd.Series(np.nan, index=partition.index, dtype=float)
-
-    # Create a boolean mask for valid, non-NaT date pairs
+
+def _vectorized_busday_count(partition, begin_col, end_col, holidays):
+    """
+    Calculates the number of business days between a start and end date.
+    """
+    # Extract the raw columns
+    start_dates_raw = partition[begin_col]
+    end_dates_raw = partition[end_col]
+
+
+    start_dates = pd.to_datetime(start_dates_raw, errors='coerce')
+    end_dates = pd.to_datetime(end_dates_raw, errors='coerce')
+
+    # Initialize the result Series with NaN, as the output is a number
+    result = pd.Series(np.nan, index=partition.index)
+
+    # Create a mask for rows where both start and end dates are valid
     valid_mask = pd.notna(start_dates) & pd.notna(end_dates)
 
-    # Perform the vectorized calculation only on the valid subset of dates
+    # Perform the vectorized calculation only on the valid subset
+    # Convert to NumPy arrays of date type for the calculation
     result.loc[valid_mask] = np.busday_count(
-        start_dates[valid_mask],
-        end_dates[valid_mask],
+        start_dates[valid_mask].values.astype('datetime64[D]'),
+        end_dates[valid_mask].values.astype('datetime64[D]'),
         holidays=holidays
     )
-    return result
 
+    return result
 
-def _vectorized_sla_end_date(
-        partition: pd.DataFrame,
-        start_col: str,
-        n_days_col: str,
-        holidays: list
-) -> pd.Series:
-    """Vectorized function to calculate the SLA end date on a DataFrame partition."""
-    if partition.empty:
-        return pd.Series([], dtype='datetime64[ns]')
 
-    start_dates = pd.to_datetime(partition[start_col], errors='coerce').dt.date
+def _vectorized_sla_end_date(partition, start_col, n_days_col, holidays):
+    """
+    Calculates the end date of an SLA, skipping weekends and holidays.
+    """
+    # Extract the relevant columns as pandas Series
+    start_dates_raw = partition[start_col]
     sla_days = partition[n_days_col]
 
-    # Create a result series filled with NaT for rows with invalid start dates
+
+    start_dates = pd.to_datetime(start_dates_raw, errors='coerce')
+
+    # Initialize the result Series with NaT (Not a Time)
     result = pd.Series(pd.NaT, index=partition.index, dtype='datetime64[ns]')
 
-    # Create a boolean mask for valid start dates and sla_days
+    # Create a mask for rows that have valid start dates and SLA days
     valid_mask = pd.notna(start_dates) & pd.notna(sla_days)
 
     # Perform the vectorized calculation only on the valid subset
+    # Note: np.busday_offset requires a NumPy array, so we use .values
     result.loc[valid_mask] = np.busday_offset(
-        start_dates[valid_mask],
+        start_dates[valid_mask].values.astype('datetime64[D]'),  # Convert to numpy array of dates
         sla_days[valid_mask].astype(int),  # Ensure days are integers
         roll='forward',
         holidays=holidays
     )
+
     return result
 
 
@@ -452,6 +452,7 @@ class BusinessDays:
                 meta=(result_col, 'datetime64[ns]')
             )}
         )
+
 # Class enhancements
 # DateUtils.register_period('next_week', lambda: (datetime.date.today() + datetime.timedelta(days=7),
 #                                                 datetime.date.today() + datetime.timedelta(days=13)))