From c0efb62d07d5312b9b8d64cc8921e4cb0087f7fa Mon Sep 17 00:00:00 2001
From: 96hoshi <marta.locascio@plan4better.de>
Date: Tue, 9 Dec 2025 09:56:13 +0000
Subject: [PATCH 01/11] fix: used bbox to find closest edge and small
 refactorings

---
 .../analysis/network/network_processor.py     | 408 +++++++++++-------
 .../benchmark_network_memory_usage.py         | 137 +++++-
 .../tests/integration/network/conftest.py     |   8 +-
 .../network/test_edge_splitting.py            |  16 +-
 .../integration/network/test_interpolation.py |  25 +-
 .../network/test_network_operations.py        |  85 ++--
 6 files changed, 441 insertions(+), 238 deletions(-)

diff --git a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
index 5873fc016..ee839a2bf 100644
--- a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
+++ b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
@@ -3,15 +3,11 @@
 from typing import Any, Dict
 
 from goatlib.analysis.core.base import AnalysisTool
-from pydantic import BaseModel, Field
+from goatlib.io.utils import Metadata
 
 logger = logging.getLogger(__name__)
 
 
-class InMemoryNetworkParams(BaseModel):
-    network_path: str = Field(..., description="Path to the network file")
-
-
 class InMemoryNetworkProcessor(AnalysisTool):
     """
     High-performance in-memory network processor for routing.
@@ -20,17 +16,16 @@ class InMemoryNetworkProcessor(AnalysisTool):
     that all resources are safely cleaned up.
 
     Example:
-        params = InMemoryNetworkParams(network_path="/path/to/network.parquet")
-        with InMemoryNetworkProcessor(params) as proc:
+        with InMemoryNetworkProcessor("/path/to/network.parquet") as proc:
             # The network is loaded and ready.
             # ... perform operations on the network ...
     """
 
-    def __init__(self, params: InMemoryNetworkParams):
+    def __init__(self, input_path: str) -> None:
         """Initializes the processor. Requires network parameters to be valid."""
         super().__init__(db_path=":memory:")
-        self.params = params
-        self.network_table_name = "in_memory_network"
+        self.input_path = input_path
+        self.network_table_name = None
         self._is_loaded = False
 
     def __enter__(self) -> "InMemoryNetworkProcessor":
@@ -42,85 +37,131 @@ def __exit__(self, exc_type, exc_val, exc_tb) -> None:
         """Exits the context, automatically cleaning up all database resources."""
         super().cleanup()
 
-    def _load_network(self) -> str:
-        """Loads the network from Parquet and converts geometry to a native type."""
-        if self._is_loaded:
-            return self.network_table_name
-
-        self.con.execute(f"""
-            CREATE TABLE {self.network_table_name} AS
-            SELECT edge_id, source, target, length_m, cost, ST_GeomFromText(geometry) as geometry
-            FROM read_parquet('{self.params.network_path}')
-        """)
-        self._is_loaded = True
-        return self.network_table_name
-
-    def _ensure_loaded(self) -> None:
-        if not self._is_loaded:
-            self._load_network()
+    # Public API Methods
+    def get_network_metadata(self) -> dict:
+        """Get metadata about the loaded network using AnalysisTool metadata functionality."""
+        self._ensure_loaded()
+        return {
+            "geometry_column": self.meta.geometry_column,
+            "geometry_type": self.meta.geometry_type,
+            "crs": self.meta.crs,
+            "columns": [
+                {"name": col.name, "type": col.type} for col in self.meta.columns
+            ],
+            "table_name": self.network_table_name,
+        }
 
-    def _generate_table_name(self, prefix: str) -> str:
-        return f"{prefix}_{uuid.uuid4().hex[:8]}"
+    def get_network_stats(self, table_name: str = None) -> Dict[str, Any]:
+        """Get basic statistics about the network."""
+        target_table = table_name or self.network_table_name
+        result = self.con.execute(f"""
+            SELECT
+                COUNT(*) as edge_count,
+                SUM(length_m) as total_length_m,
+                AVG(length_m) as avg_length_m,
+                MIN(length_m) as min_length_m,
+                MAX(length_m) as max_length_m
+            FROM {target_table}
+        """).fetchone()
 
-    def cleanup_intermediate_tables(self) -> None:
-        """
-        Explicitly cleans all generated tables, keeping only the original network table.
-        This allows for manual memory management during long, complex workflows.
-        """
-        all_tables = self.con.execute(
-            "SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'"
-        ).fetchall()
-        for (table_name,) in all_tables:
-            # Do not drop the main table or DuckDB's internal spatial reference table
-            if table_name not in [self.network_table_name, "spatial_ref_sys"]:
-                self.con.execute(f"DROP TABLE IF EXISTS {table_name}")
-        logger.info(f"Cleaned up intermediate tables. Kept: {self.network_table_name}")
+        return {
+            "edge_count": result[0],
+            "total_length_m": float(result[1]) if result[1] else 0,
+            "avg_length_m": float(result[2]) if result[2] else 0,
+            "min_length_m": float(result[3]) if result[3] else 0,
+            "max_length_m": float(result[4]) if result[4] else 0,
+        }
 
     def get_available_tables(self) -> list[str]:
         """Get list of available table names in the database."""
-        tables = self.con.execute(
-            "SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'"
-        ).fetchall()
-        return [table[0] for table in tables]
+        result = self.con.execute("SHOW TABLES").fetchall()
+        return [table[0] for table in result]
 
-    def apply_sql_query(self, sql_query: str) -> str:
+    def apply_sql_query(
+        self, sql_query: str, result_table_prefix: str = "query_result"
+    ) -> str:
         """Applies SQL and returns a NEW table, without destroying the input."""
         self._ensure_loaded()
-        result_table = self._generate_table_name("query_result")
-        # WARNING: This does not sanitize input SQL - use with caution. Add validation as needed.
-        self.con.execute(f"CREATE TABLE {result_table} AS {sql_query}")
-        return result_table
-
+        result_table = self._generate_table_name(result_table_prefix)
+        try:
+            # WARNING: This does not sanitize input SQL - use with caution in production
+            self.con.execute(f"CREATE TABLE {result_table} AS {sql_query}")
+            logger.info(f"Created result table: {result_table}")
+            return result_table
+        except Exception as e:
+            logger.error(f"Failed to execute SQL query: {e}")
+            raise
+
+    # Network Analysis Methods
     def split_edge_at_point(
         self,
         latitude: float,
         longitude: float,
         base_table: str = None,
-    ) -> tuple[str, dict[str, Any]]:
+        max_search_radius: float = 200.0,
+        include_stats: bool = True,
+    ) -> tuple[str, Metadata]:
         """
-        Finds the closest edge to a point, splits it, and creates a new network table
-        using DuckDB's spatial extension.
+        Finds the closest edge to a point, splits it, and creates a new network table.
+
+        Uses bbox optimization with spatial indexing for efficient edge searching.
+
+        Args:
+            latitude: Latitude of the split point
+            longitude: Longitude of the split point
+            base_table: Source table name (defaults to main network table)
+            max_search_radius: Maximum search radius in meters
+            include_stats: Whether to include edge count statistics (default: True)
 
-        This version uses CTEs instead of a temporary table to simplify the SQL
-        and reduce database interactions.
+        Returns:
+            Tuple of (table_name, metadata) with split operation details in raw_meta
         """
         self._ensure_loaded()
         source_table = base_table or self.network_table_name
         split_table_name = self._generate_table_name("split_network")
         new_node_id = f"split_node_{uuid.uuid4().hex[:8]}"
         point_geom = f"ST_Point({longitude}, {latitude})"
+        geom_col = self.meta.geometry_column
+
+        # Calculate rough bbox around the point (in degrees, approximate)
+        bbox_size = max_search_radius / 111000.0  # rough meters to degrees conversion
+
+        info_query = f"""
+        SELECT
+            edge_id,
+            ST_LineLocatePoint({geom_col}, {point_geom}) as split_fraction,
+            ST_X(ST_LineInterpolatePoint({geom_col}, ST_LineLocatePoint({geom_col}, {point_geom}))) as split_lon,
+            ST_Y(ST_LineInterpolatePoint({geom_col}, ST_LineLocatePoint({geom_col}, {point_geom}))) as split_lat,
+            ST_Distance({geom_col}, {point_geom}) as distance
+        FROM {source_table}
+        WHERE ST_Intersects({geom_col}, ST_MakeEnvelope(
+            {longitude - bbox_size}, {latitude - bbox_size},
+            {longitude + bbox_size}, {latitude + bbox_size}
+        ))
+        AND ST_Distance({geom_col}, {point_geom}) <= {max_search_radius}
+        ORDER BY ST_Distance({geom_col}, {point_geom}) ASC
+        LIMIT 1
+        """
 
-        # Create the split network table using a single CTE-based query
+        info_res = self.con.execute(info_query).fetchone()
+
+        # Check if any edge was found
+        if not info_res or info_res[0] is None:
+            raise ValueError(
+                f"No edges found within {max_search_radius}m of point ({latitude}, {longitude}). "
+                f"Try increasing max_search_radius or check if the point is near the network."
+            )
+
+        # Extract info for later use
+        original_edge_id, split_fraction, split_lon, split_lat, distance = info_res
+
+        # Now create the split table using the found edge
         split_query = f"""
         CREATE TABLE {split_table_name} AS
-        WITH closest_edge AS (
-            -- Find the single edge closest to the split point and calculate split position
-            SELECT
-                *,
-                ST_LineLocatePoint(geometry, {point_geom}) as split_fraction
-            FROM {source_table}
-            ORDER BY ST_Distance(geometry, {point_geom}) ASC
-            LIMIT 1
+        WITH target_edge AS (
+            -- Select the specific edge we found
+            SELECT * FROM {source_table}
+            WHERE edge_id = '{original_edge_id}'
         ),
         new_split_parts AS (
             -- Create two new edge segments from the original edge at the split point
@@ -129,11 +170,10 @@ def split_edge_at_point(
                 edge_id || '_part_a' as edge_id,
                 source,
                 '{new_node_id}' as target,
-                length_m * split_fraction AS length_m,
-                cost * split_fraction AS cost,
-                ST_LineSubstring(geometry, 0.0, split_fraction) as geometry
-            FROM closest_edge
-            WHERE split_fraction > 1e-9 -- Only create if split point is not at start
+                length_m * {split_fraction} AS length_m,
+                cost * {split_fraction} AS cost,
+                ST_LineSubstring({geom_col}, 0.0, {split_fraction}) as {geom_col}
+            FROM target_edge
 
             UNION ALL
 
@@ -142,66 +182,65 @@ def split_edge_at_point(
                 edge_id || '_part_b' as edge_id,
                 '{new_node_id}' as source,
                 target,
-                length_m * (1.0 - split_fraction) AS length_m,
-                cost * (1.0 - split_fraction) AS cost,
-                ST_LineSubstring(geometry, split_fraction, 1.0) as geometry
-            FROM closest_edge
-            WHERE split_fraction < 1.0 - 1e-9 -- Only create if split point is not at end
+                length_m * (1.0 - {split_fraction}) AS length_m,
+                cost * (1.0 - {split_fraction}) AS cost,
+                ST_LineSubstring({geom_col}, {split_fraction}, 1.0) as {geom_col}
+            FROM target_edge
         )
         -- Combine all unchanged edges with the new split edge parts
-        SELECT edge_id, source, target, length_m, cost, geometry FROM {source_table}
-        WHERE edge_id <> (SELECT edge_id FROM closest_edge)
+        SELECT * FROM {source_table}
+        WHERE edge_id <> '{original_edge_id}'
         UNION ALL
-        SELECT edge_id, source, target, length_m, cost, geometry FROM new_split_parts;
+        SELECT * FROM new_split_parts;
         """
         self.con.execute(split_query)
 
-        # Query to extract information about the split operation
-        info_query = f"""
-        WITH closest_edge AS (
-            -- Re-find the closest edge to get split details (stateless approach)
-            SELECT
-                *,
-                ST_LineLocatePoint(geometry, {point_geom}) as split_fraction
-            FROM {source_table}
-            ORDER BY ST_Distance(geometry, {point_geom}) ASC
-            LIMIT 1
-        )
-        SELECT
-            edge_id,                                                             -- Original edge ID
-            split_fraction,                                                      -- Position along edge (0.0 to 1.0)
-            ST_X(ST_LineInterpolatePoint(geometry, split_fraction)) as lon,      -- Longitude of split point
-            ST_Y(ST_LineInterpolatePoint(geometry, split_fraction)) as lat       -- Latitude of split point
-        FROM closest_edge;
-        """
-        info_res = self.con.execute(info_query).fetchone()
+        # Create metadata for the split table using fast path (same schema as original)
+        split_meta = self._create_metadata_from_template(split_table_name)
 
-        # Package split operation results
-        split_info = {
+        # Add split operation details to metadata
+        split_operation_info = {
+            "operation": "edge_split",
+            "method": "bbox_optimization",
             "artificial_node_id": new_node_id,
-            "original_edge_split": info_res[0],
-            "split_fraction": info_res[1],
+            "original_edge_split": original_edge_id,
+            "split_fraction": split_fraction,
+            "distance_to_edge": distance,
+            "max_search_radius": max_search_radius,
             "new_node_coords": {
-                "lon": info_res[2],
-                "lat": info_res[3],
+                "lon": split_lon,
+                "lat": split_lat,
             },
         }
 
-        # The warning logic is adjusted to account for floating point inaccuracies.
-        if not (1e-9 < split_info["split_fraction"] < 1.0 - 1e-9):
+        # Optionally include statistics (can be expensive for large networks)
+        if include_stats:
+            split_operation_info.update(
+                {
+                    "original_edge_count": self.get_network_stats()["edge_count"],
+                    "split_edge_count": self.get_network_stats(split_table_name)[
+                        "edge_count"
+                    ],
+                }
+            )
+
+        split_meta.raw_meta["split_operation"] = split_operation_info
+
+        # Warning for edge cases
+        if not (1e-9 < split_fraction < 1.0 - 1e-9):
             logger.warning(
-                f"Split point is at or very near an existing node (fraction={split_info['split_fraction']:.6f}). "
+                f"Split point is at or very near an existing node (fraction={split_fraction:.6f}). "
                 "The original edge was effectively replaced, not split into two new segments."
             )
 
-        return split_table_name, split_info
+        return split_table_name, split_meta
 
     def interpolate_long_edges(
         self,
         max_edge_length: float,
         base_table: str = None,
         interpolation_distance: float = None,
-    ) -> tuple[str, dict[str, Any]]:
+    ) -> tuple[str, Metadata]:
         """
         Interpolate nodes along edges that are longer than the specified threshold.
         Creates actual intermediate nodes with coordinates and splits edges accordingly.
@@ -212,8 +251,8 @@ def interpolate_long_edges(
             interpolation_distance: Distance between interpolated points (defaults to max_edge_length/2)
 
         Returns:
-            Tuple of (table_name, interpolation_info) where interpolation_info contains
-            statistics about the interpolation process
+            Tuple of (table_name, metadata) where metadata contains table schema
+            and interpolation details in raw_meta
         """
         import time
 
@@ -226,9 +265,19 @@ def interpolate_long_edges(
         if interpolation_distance is None:
             interpolation_distance = max_edge_length / 2
 
+        # Use metadata geometry column for dynamic column handling
+        geom_column = self.meta.geometry_column
+
+        # Combined query: create table and get statistics in one go
         interpolation_query = f"""
         CREATE TABLE {interpolated_table} AS
-        WITH long_edges AS (
+        WITH original_stats AS (
+            SELECT
+                COUNT(*) as original_edges,
+                COUNT(*) FILTER (WHERE length_m > {max_edge_length}) as long_edges_count
+            FROM {source_table}
+        ),
+        long_edges AS (
             -- Identify edges that need interpolation and calculate segments needed
             SELECT *,
                    CAST(CEIL(length_m / {interpolation_distance}) AS INTEGER) as num_segments
@@ -237,46 +286,45 @@ def interpolate_long_edges(
         ),
         interpolated_segments AS (
             -- Generate new edges with intermediate nodes
-            SELECT 
+            SELECT
                 edge_id || '_seg_' || CAST(segment_id AS VARCHAR) as edge_id,
-                CASE 
+                CASE
                     WHEN segment_id = 1 THEN CAST(source AS VARCHAR)
                     ELSE 'interp_' || edge_id || '_' || CAST((segment_id - 1) AS VARCHAR)
                 END as source,
-                CASE 
+                CASE
                     WHEN segment_id = num_segments THEN CAST(target AS VARCHAR)
                     ELSE 'interp_' || edge_id || '_' || CAST(segment_id AS VARCHAR)
                 END as target,
                 length_m / num_segments as length_m,
                 cost / num_segments as cost,
                 ST_LineSubstring(
-                    geometry, 
-                    (segment_id - 1.0) / num_segments, 
+                    {geom_column},
+                    (segment_id - 1.0) / num_segments,
                     segment_id / num_segments
-                ) as geometry
+                ) as {geom_column}
             FROM long_edges
             CROSS JOIN generate_series(1, num_segments) as t(segment_id)
         )
         -- Combine short edges (unchanged) with interpolated segments
-        SELECT edge_id, source, target, length_m, cost, geometry
+        SELECT edge_id, source, target, length_m, cost, {geom_column}
         FROM {source_table}
         WHERE length_m <= {max_edge_length}
 
         UNION ALL
 
-        SELECT edge_id, source, target, length_m, cost, geometry
+        SELECT edge_id, source, target, length_m, cost, {geom_column}
         FROM interpolated_segments
         ORDER BY edge_id;
         """
 
         self.con.execute(interpolation_query)
-
         processing_time = time.time() - start_time
 
-        # Get interpolation statistics
+        # Get statistics in single optimized query
         stats_query = f"""
         WITH original_stats AS (
-            SELECT 
+            SELECT
                 COUNT(*) as original_edges,
                 COUNT(*) FILTER (WHERE length_m > {max_edge_length}) as long_edges_count
             FROM {source_table}
@@ -285,13 +333,13 @@ def interpolate_long_edges(
             SELECT COUNT(*) as new_edges FROM {interpolated_table}
         ),
         node_stats AS (
-            SELECT 
+            SELECT
                 COUNT(DISTINCT source) + COUNT(DISTINCT target) as total_nodes,
-                COUNT(DISTINCT source) FILTER (WHERE source LIKE 'interp_%') + 
+                COUNT(DISTINCT source) FILTER (WHERE source LIKE 'interp_%') +
                 COUNT(DISTINCT target) FILTER (WHERE target LIKE 'interp_%') as new_nodes
             FROM {interpolated_table}
         )
-        SELECT 
+        SELECT
             o.original_edges,
             o.long_edges_count,
             n.new_edges,
@@ -302,51 +350,97 @@ def interpolate_long_edges(
 
         stats_result = self.con.execute(stats_query).fetchone()
 
-        interpolation_info = {
+        # Create metadata for the interpolated table using fast path
+        interpolated_meta = self._create_metadata_from_template(interpolated_table)
+
+        # Embed interpolation details in raw_meta
+        interpolated_meta.raw_meta = interpolated_meta.raw_meta or {}
+        interpolated_meta.raw_meta["interpolation_operation"] = {
             "original_edge_count": stats_result[0],
             "long_edges_processed": stats_result[1],
             "final_edge_count": stats_result[2],
             "new_intermediate_nodes": stats_result[3],
             "total_nodes": stats_result[4],
+            "edges_added": stats_result[2] - stats_result[0],
             "max_edge_length_threshold": max_edge_length,
             "interpolation_distance": interpolation_distance,
             "processing_time_seconds": processing_time,
         }
 
-        return interpolated_table, interpolation_info
+        return interpolated_table, interpolated_meta
 
-    def get_network_stats(self, table_name: str = None) -> Dict[str, Any]:
-        """Get basic statistics about the network."""
-        target_table = table_name or self.network_table_name
-        result = self.con.execute(f"""
-            SELECT
-                COUNT(*) as edge_count,
-                SUM(length_m) as total_length_m,
-                AVG(length_m) as avg_length_m,
-                MIN(length_m) as min_length_m,
-                MAX(length_m) as max_length_m
-            FROM {target_table}
-        """).fetchone()
-
-        return {
-            "edge_count": result[0],
-            "total_length_m": float(result[1]) if result[1] else 0,
-            "avg_length_m": float(result[2]) if result[2] else 0,
-            "min_length_m": float(result[3]) if result[3] else 0,
-            "max_length_m": float(result[4]) if result[4] else 0,
-        }
-
-    def save_table_to_file(self, table_name: str, output_path: str) -> None:
-        """Save table to parquet file."""
-        self.con.execute(
-            f"COPY {table_name} TO '{output_path}' (FORMAT PARQUET, COMPRESSION ZSTD)"
-        )
+    # File I/O Methods
+    def save_table_to_file(
+        self, table_name: str, output_path: str, format: str = "PARQUET"
+    ) -> None:
+        """Save table to file with preserved geometry. Supports PARQUET, GPKG, etc."""
+        if format.upper() == "PARQUET":
+            self.con.execute(
+                f"COPY {table_name} TO '{output_path}' (FORMAT PARQUET, COMPRESSION ZSTD)"
+            )
+        else:
+            # Use DuckDB's spatial export for other formats
+            self.con.execute(
+                f"COPY {table_name} TO '{output_path}' WITH (FORMAT GDAL, DRIVER '{format}')"
+            )
 
-    def save_table_to_tmp(self, table_name: str) -> str:
-        """Save table to a temporary parquet file and return the path."""
+    def save_table_to_tmp(self, table_name: str, format: str = "PARQUET") -> str:
+        """Save table to a temporary file and return the path."""
         import tempfile
 
-        with tempfile.NamedTemporaryFile(suffix=".parquet", delete=False) as tmp_file:
+        suffix = ".parquet" if format.upper() == "PARQUET" else ".gpkg"
+        with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp_file:
             output_path = tmp_file.name
-        self.save_table_to_file(table_name, output_path)
+        self.save_table_to_file(table_name, output_path, format)
         return output_path
+
+    # Private Helper Methods
+    def _ensure_loaded(self) -> None:
+        if not self._is_loaded:
+            self.network_table_name = self._load_network()
+
+    def _load_network(self) -> None:
+        """Load the network file using the parent class import functionality."""
+        if self._is_loaded:
+            return
+
+        self.network_table_name = self._generate_table_name("v_input")
+
+        # Import using the parent class method which handles metadata correctly
+        self.meta, self.network_table_name = super().import_input(
+            self.input_path, table_name=self.network_table_name
+        )
+
+        self._is_loaded = True
+        self._validate_network_schema()
+
+    def _validate_network_schema(self) -> None:
+        """Validate that the loaded network has required columns."""
+        required_columns = {"edge_id", "source", "target", "geometry"}
+
+        # Get actual column names from metadata
+        actual_columns = {col.name for col in self.meta.columns}
+
+        missing_columns = required_columns - actual_columns
+        if missing_columns:
+            raise ValueError(
+                f"Network file missing required columns: {missing_columns}. "
+                f"Available columns: {actual_columns}"
+            )
+
+        # Validate geometry column exists
+        if not self.meta.geometry_column:
+            raise ValueError("Network file must have a geometry column")
+
+    def _generate_table_name(self, prefix: str) -> str:
+        return f"{prefix}_{uuid.uuid4().hex[:8]}"
+
+    def _create_metadata_from_template(self, table_name: str) -> Metadata:
+        """Create metadata for tables with the same schema as the original network (fast path)."""
+        return Metadata(
+            geometry_column=self.meta.geometry_column,
+            geometry_type=self.meta.geometry_type,
+            crs=self.meta.crs,
+            columns=self.meta.columns,  # Reuse original columns since schema is identical
+            raw_meta={},
+        )
diff --git a/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py b/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
index a45b1216b..518dbbbd7 100644
--- a/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
+++ b/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
@@ -3,6 +3,7 @@
 import time
 from pathlib import Path
 
+
 try:
     import psutil
 
@@ -11,10 +12,7 @@
     PSUTIL_AVAILABLE = False
 
 import pytest
-from goatlib.analysis.network.network_processor import (
-    InMemoryNetworkParams,
-    InMemoryNetworkProcessor,
-)
+from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
 
 logging.basicConfig(
     level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
@@ -22,13 +20,15 @@
 
 
 # --- Helper Functions ---
-def get_memory_mb():
+def get_memory_mb() -> dict[str, float]:
     process = psutil.Process()
     mem_info = process.memory_info()
     return {"rss": mem_info.rss / (1024**2), "vms": mem_info.vms / (1024**2)}
 
 
-def print_memory(stage, current, baseline):
+def print_memory(
+    stage: str, current: dict[str, float], baseline: dict[str, float]
+) -> None:
     rss_delta = current["rss"] - baseline["rss"]
     vms_delta = current["vms"] - baseline["vms"]
     print(
@@ -37,7 +37,8 @@ def print_memory(stage, current, baseline):
 
 
 # --- Main Benchmark ---
-def run_benchmark(network_path: str | None = None):
+def run_lightweight_benchmark(network_path: str | None = None) -> None:
+    """Lightweight benchmark matching the original performance test."""
     # Get network path from conftest fixture location if not provided
     if network_path is None:
         network_path = str(
@@ -49,7 +50,7 @@ def run_benchmark(network_path: str | None = None):
         return
 
     print("=" * 80)
-    print("🧠 In-Memory Network Processor: Performance and Memory Benchmark")
+    print("🚀 Lightweight Network Processor: Performance Benchmark (Original)")
     print("=" * 80)
 
     gc.collect()
@@ -59,26 +60,116 @@ def run_benchmark(network_path: str | None = None):
     )
 
     stages = []
-    params = InMemoryNetworkParams(network_path=network_path)
     total_time_start = time.perf_counter()
 
-    with InMemoryNetworkProcessor(params) as proc:
+    with InMemoryNetworkProcessor(network_path) as proc:
         stages.append(("After Loading", get_memory_mb()))
         stats = proc.get_network_stats()
         original_table = proc.network_table_name
-        filtered = proc.apply_sql_query(
-            f"SELECT * FROM {original_table} WHERE length_m > 100"
-        )
+
+        # Create a filtered network (matching original)
+        filtered_table = proc._generate_table_name("filtered_network")
+        proc.con.execute(f"""
+            CREATE TABLE {filtered_table} AS 
+            SELECT * FROM {original_table} WHERE length_m > 100
+        """)
         stages.append(("After Filtering", get_memory_mb()))
 
-        split, _ = proc.split_edge_at_point(
-            latitude=48.13, longitude=11.58, base_table=filtered
+        # Test edge splitting only (matching original)
+        try:
+            split_table, split_meta = proc.split_edge_at_point(
+                latitude=48.13,
+                longitude=11.58,
+                # base_table=filtered_table,
+            )
+            stages.append(("After Edge Split", get_memory_mb()))
+        except ValueError as e:
+            print(f"Split operation failed: {e}")
+            stages.append(("After Failed Split", get_memory_mb()))
+
+        # Cleanup intermediate (matching original)
+        stages.append(("After Intermediate Cleanup", get_memory_mb()))
+
+    total_time_end = time.perf_counter()
+    gc.collect()
+    stages.append(("Final (After Full Cleanup)", get_memory_mb()))
+
+    # Print all stages
+    for stage_name, memory_data in stages:
+        print_memory(stage_name, memory_data, baseline_memory)
+
+    # Summary
+    total_duration = total_time_end - total_time_start
+    peak_rss = max(stage_data["rss"] for _, stage_data in stages)
+    print("-" * 80)
+    print("📊 Summary:")
+    print(f"Total processing time: {total_duration:.3f} seconds")
+    print(
+        f"Peak Physical Memory (RSS) Increase: {peak_rss - baseline_memory['rss']:.1f} MB"
+    )
+    print(f"Processing Rate: {stats['edge_count'] / total_duration:,.0f} edges/second")
+    print("=" * 80)
+
+
+def run_full_benchmark(network_path: str | None = None):
+    """Full benchmark including interpolation and advanced features."""
+    # Get network path from conftest fixture location if not provided
+    if network_path is None:
+        network_path = str(
+            Path(__file__).parent.parent / "data" / "network" / "network.parquet"
         )
-        stages.append(("After Edge Split", get_memory_mb()))
 
-        proc.cleanup_intermediate_tables()
-        stages.append(("After Intermediate Cleanup", get_memory_mb()))
+    if not (PSUTIL_AVAILABLE and Path(network_path).exists()):
+        print("psutil or network file not available. Aborting benchmark.")
+        return
 
+    print("=" * 80)
+    print("🧠 Full Network Processor: Performance and Memory Benchmark")
+    print("=" * 80)
+
+    gc.collect()
+    baseline_memory = get_memory_mb()
+    print(
+        f"Baseline                     | RSS: {baseline_memory['rss']:>7.1f} MB          | VMS: {baseline_memory['vms']:>8.1f} MB"
+    )
+
+    stages = []
+    total_time_start = time.perf_counter()
+
+    with InMemoryNetworkProcessor(network_path) as proc:
+        stages.append(("After Loading", get_memory_mb()))
+        stats = proc.get_network_stats()
+        original_table = proc.network_table_name
+
+        # Create a filtered network
+        filtered_table = proc._generate_table_name("filtered_network")
+        proc.con.execute(f"""
+            CREATE TABLE {filtered_table} AS 
+            SELECT * FROM {original_table} WHERE length_m > 100
+        """)
+        stages.append(("After Filtering", get_memory_mb()))
+
+        # Test edge splitting
+        try:
+            split_table, split_meta = proc.split_edge_at_point(
+                latitude=48.13,
+                longitude=11.58,
+                base_table=filtered_table,
+            )
+            stages.append(("After Edge Split", get_memory_mb()))
+        except ValueError as e:
+            print(f"Split operation failed: {e}")
+            stages.append(("After Failed Split", get_memory_mb()))
+
+        # Test interpolation
+        try:
+            interp_table, interp_meta = proc.interpolate_long_edges(
+                max_edge_length=200.0, base_table=original_table
+            )
+            stages.append(("After Interpolation", get_memory_mb()))
+        except Exception as e:
+            print(f"Interpolation failed: {e}")
+            stages.append(("After Failed Interpolation", get_memory_mb()))
     total_time_end = time.perf_counter()
     gc.collect()
     stages.append(("Final (After Full Cleanup)", get_memory_mb()))
@@ -106,8 +197,14 @@ def test_benchmark_with_fixture(network_file: Path):
     if not PSUTIL_AVAILABLE:
         pytest.skip("psutil not available for memory monitoring")
 
-    run_benchmark(str(network_file))
+    run_lightweight_benchmark(str(network_file))
 
 
 if __name__ == "__main__":
-    run_benchmark()
+    print("Running lightweight benchmark (matching original)...")
+    run_lightweight_benchmark()
+
+    print("\n" + "=" * 80 + "\n")
+
+    print("Running full benchmark (with interpolation)...")
+    run_full_benchmark()
diff --git a/packages/python/goatlib/tests/integration/network/conftest.py b/packages/python/goatlib/tests/integration/network/conftest.py
index 37e97c144..bbffcf7f4 100644
--- a/packages/python/goatlib/tests/integration/network/conftest.py
+++ b/packages/python/goatlib/tests/integration/network/conftest.py
@@ -1,16 +1,12 @@
 from pathlib import Path
 
 import pytest
-from goatlib.analysis.network.network_processor import (
-    InMemoryNetworkParams,
-    InMemoryNetworkProcessor,
-)
+from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
 
 
 @pytest.fixture
 def processor(network_file: Path) -> InMemoryNetworkProcessor:
     """A pytest fixture that yields a processor within a context manager."""
-    params = InMemoryNetworkParams(network_path=str(network_file))
-    with InMemoryNetworkProcessor(params) as proc:
+    with InMemoryNetworkProcessor(str(network_file)) as proc:
         yield proc
     # Cleanup is handled automatically as the 'with' block exits
diff --git a/packages/python/goatlib/tests/integration/network/test_edge_splitting.py b/packages/python/goatlib/tests/integration/network/test_edge_splitting.py
index e878c0c46..0d604f132 100644
--- a/packages/python/goatlib/tests/integration/network/test_edge_splitting.py
+++ b/packages/python/goatlib/tests/integration/network/test_edge_splitting.py
@@ -12,7 +12,10 @@ def test_split_output_and_properties(processor: InMemoryNetworkProcessor) -> Non
     Tests the `split_info` dictionary for correctness and reasonable values.
     This combines 'test_basic_edge_split' and 'test_split_info_coordinates'.
     """
-    _, split_info = processor.split_edge_at_point(latitude=48.13, longitude=11.58)
+    _, split_meta = processor.split_edge_at_point(latitude=48.13, longitude=11.58)
+
+    # Extract split info from metadata
+    split_info = split_meta.raw_meta["split_operation"]
 
     # Verify structure and existence of keys
     assert split_info["artificial_node_id"] is not None
@@ -40,9 +43,12 @@ def test_split_topology_and_invariance(processor: InMemoryNetworkProcessor) -> N
     original_stats = processor.get_network_stats()
     original_table_name = processor.network_table_name
 
-    split_table, split_info = processor.split_edge_at_point(
+    split_table, split_meta = processor.split_edge_at_point(
         latitude=48.13, longitude=11.58
     )
+
+    # Extract split info from metadata
+    split_info = split_meta.raw_meta["split_operation"]
     split_stats = processor.get_network_stats(split_table)
     original_edge_id = split_info["original_edge_split"]
     new_node_id = split_info["artificial_node_id"]
@@ -109,7 +115,7 @@ def test_comprehensive_workflow(processor: InMemoryNetworkProcessor) -> None:
     assert filtered_stats["edge_count"] < original_stats["edge_count"]
 
     # Step 2: Split on the filtered network
-    split_table, _ = processor.split_edge_at_point(
+    split_table, split_meta = processor.split_edge_at_point(
         latitude=48.13, longitude=11.58, base_table=filtered_table
     )
     split_stats = processor.get_network_stats(split_table)
@@ -131,7 +137,9 @@ def test_split_is_non_destructive(processor: InMemoryNetworkProcessor) -> None:
     original_table_name = processor.network_table_name
 
     # Perform the split operation
-    processor.split_edge_at_point(latitude=48.13, longitude=11.58)
+    split_table, split_meta = processor.split_edge_at_point(
+        latitude=48.13, longitude=11.58
+    )
 
     # Verify that the original table was not altered
     post_split_stats = processor.get_network_stats(original_table_name)
diff --git a/packages/python/goatlib/tests/integration/network/test_interpolation.py b/packages/python/goatlib/tests/integration/network/test_interpolation.py
index d10bb5b22..cd7d993bd 100644
--- a/packages/python/goatlib/tests/integration/network/test_interpolation.py
+++ b/packages/python/goatlib/tests/integration/network/test_interpolation.py
@@ -27,10 +27,13 @@ def test_interpolate_long_edges(processor: InMemoryNetworkProcessor) -> None:
     interpolation_distance = max_length / 3  # Create multiple segments
 
     # Perform interpolation
-    interpolated_table, info = processor.interpolate_long_edges(
+    interpolated_table, interpolated_meta = processor.interpolate_long_edges(
         max_edge_length=max_length, interpolation_distance=interpolation_distance
     )
 
+    # Extract interpolation info from metadata
+    info = interpolated_meta.raw_meta["interpolation_operation"]
+
     # Verify interpolation info
     assert info["original_edge_count"] == original_stats["edge_count"]
     assert info["max_edge_length_threshold"] == max_length
@@ -86,10 +89,13 @@ def test_interpolate_with_custom_distance(processor: InMemoryNetworkProcessor) -
     max_length = 200.0
     interpolation_distance = 50.0
 
-    interpolated_table, info = processor.interpolate_long_edges(
+    interpolated_table, interpolated_meta = processor.interpolate_long_edges(
         max_edge_length=max_length, interpolation_distance=interpolation_distance
     )
 
+    # Extract interpolation info from metadata
+    info = interpolated_meta.raw_meta["interpolation_operation"]
+
     # Verify configuration was used
     assert info["max_edge_length_threshold"] == max_length
     assert info["interpolation_distance"] == interpolation_distance
@@ -109,23 +115,16 @@ def test_interpolate_default_distance(processor: InMemoryNetworkProcessor) -> No
     """Test edge interpolation with default interpolation distance."""
     max_length = 100.0
 
-    interpolated_table, info = processor.interpolate_long_edges(
+    interpolated_table, interpolated_meta = processor.interpolate_long_edges(
         max_edge_length=max_length
     )
 
+    # Extract interpolation info from metadata
+    info = interpolated_meta.raw_meta["interpolation_operation"]
+
     # Verify default interpolation distance was used (half of max_length)
     assert info["interpolation_distance"] == max_length / 2
     assert info["max_edge_length_threshold"] == max_length
 
     # Check that interpolation worked
     assert info["final_edge_count"] >= info["original_edge_count"]
-
-
-# Interpolation test completed:
-# Original edges:           375164
-# Long edges processed:     93791
-# Final edges:              1021482
-# New intermediate nodes:   1279968
-# Max edge length threshold: 51.2m
-# Processing time:           0.16s
-# PASSED
diff --git a/packages/python/goatlib/tests/integration/network/test_network_operations.py b/packages/python/goatlib/tests/integration/network/test_network_operations.py
index c2f903950..3f000c4a6 100644
--- a/packages/python/goatlib/tests/integration/network/test_network_operations.py
+++ b/packages/python/goatlib/tests/integration/network/test_network_operations.py
@@ -1,4 +1,5 @@
 import logging
+from pathlib import Path
 
 from goatlib.analysis.network.network_processor import (
     InMemoryNetworkProcessor,
@@ -64,45 +65,44 @@ def test_get_available_tables(processor: InMemoryNetworkProcessor) -> None:
     logger.info(f"Available tables: {tables_after}")
 
 
-def test_cleanup_intermediate_tables(processor: InMemoryNetworkProcessor) -> None:
-    """Test that explicit cleanup removes intermediate tables but leaves the base network."""
-    # Create intermediate tables explicitly using the base table name
-    base_table_name = processor.network_table_name
-    table1 = processor.apply_sql_query(
-        f"SELECT * FROM {base_table_name} WHERE length_m > 100"
-    )
-    table2 = processor.apply_sql_query(
-        f"SELECT * FROM {base_table_name} WHERE cost > 50"
-    )
-
-    # Verify they exist
-    all_tables_before = {
-        t[0]
-        for t in processor.con.execute(
-            "SELECT table_name FROM information_schema.tables"
-        ).fetchall()
-    }
-    assert table1 in all_tables_before
-    assert table2 in all_tables_before
-
-    # Perform cleanup
-    processor.cleanup_intermediate_tables()
-
-    # Verify they are gone, but the main table remains
-    all_tables_after = {
-        t[0]
-        for t in processor.con.execute(
-            "SELECT table_name FROM information_schema.tables"
-        ).fetchall()
-    }
-    assert table1 not in all_tables_after
-    assert table2 not in all_tables_after
-    assert processor.network_table_name in all_tables_after
+def test_context_manager_cleanup(network_file: Path) -> None:
+    """Test that context manager properly handles cleanup when exiting the block."""
+    # Use the context manager to create a processor
+    table_names_inside = None
+    network_table_name = None
+
+    with InMemoryNetworkProcessor(str(network_file)) as processor:
+        # Create some intermediate tables
+        network_table_name = processor.network_table_name
+        table1 = processor.apply_sql_query(
+            f"SELECT * FROM {network_table_name} WHERE length_m > 100"
+        )
+        table2 = processor.apply_sql_query(
+            f"SELECT * FROM {network_table_name} WHERE cost > 50"
+        )
+
+        # Verify they exist while inside the context
+        table_names_inside = {
+            t[0]
+            for t in processor.con.execute(
+                "SELECT table_name FROM information_schema.tables"
+            ).fetchall()
+        }
+        assert table1 in table_names_inside
+        assert table2 in table_names_inside
+        assert network_table_name in table_names_inside
+
+    # After exiting the context manager, the processor's connection should be closed
+    # and cleanup should have been performed automatically
+    assert table_names_inside is not None
+    assert (
+        len(table_names_inside) >= 3
+    )  # At minimum: network table + 2 intermediate tables
 
 
 def test_save_to_file(processor: InMemoryNetworkProcessor, tmp_path: str) -> None:
     """Test saving a table to a parquet file."""
-    output_file = tmp_path / "network_output.parquet"
+    output_file = Path("./network_output.parquet")
     processor.save_table_to_file(processor.network_table_name, str(output_file))
 
     # Verify the file was created
@@ -127,14 +127,12 @@ def test_concurrent_access(network_file: str) -> None:
     import concurrent.futures
 
     from goatlib.analysis.network.network_processor import (
-        InMemoryNetworkParams,
         InMemoryNetworkProcessor,
     )
 
     def create_processor_and_get_stats() -> dict:
         # Each thread gets its own processor instance with its own connection
-        params = InMemoryNetworkParams(network_path=str(network_file))
-        with InMemoryNetworkProcessor(params) as proc:
+        with InMemoryNetworkProcessor(str(network_file)) as proc:
             return proc.get_network_stats()
 
     # Use a smaller number of workers to avoid resource exhaustion
@@ -151,3 +149,14 @@ def create_processor_and_get_stats() -> dict:
     assert (
         len(set(edge_counts)) == 1
     ), "All processors should report the same edge count"
+
+
+def test_network_is_wkb_format(processor: InMemoryNetworkProcessor) -> None:
+    """Test that the network geometries are in WKB format."""
+    sample_geometry = processor.con.execute(
+        f"SELECT geometry FROM {processor.network_table_name} LIMIT 1"
+    ).fetchone()[0]
+
+    assert isinstance(
+        sample_geometry, bytes
+    ), f"Geometry should be in WKB format (bytes), got {type(sample_geometry)}"

From 7bbced3a2bbcddb66849ee8b7be5efdb38959317 Mon Sep 17 00:00:00 2001
From: 96hoshi <marta.locascio@plan4better.de>
Date: Tue, 9 Dec 2025 14:39:49 +0000
Subject: [PATCH 02/11] style: more pythonic classes for catchment

---
 .../adapters/motis/motis_converters.py        |  41 +-
 .../routing/adapters/motis/motis_mappings.py  | 127 +++---
 .../routing/adapters/motis/motis_settings.py  |  14 +-
 .../goatlib/src/goatlib/routing/config.py     |  80 ++++
 .../src/goatlib/routing/schemas/ab_routing.py |  16 +-
 .../src/goatlib/routing/schemas/base.py       | 118 ++---
 .../src/goatlib/routing/schemas/catchment.py  |  55 +++
 .../routing/schemas/catchment_area_active.py  | 404 ++++++++----------
 .../routing/schemas/catchment_area_transit.py | 232 ++++++----
 .../routing/utils/ab_route_validator.py       |  48 +--
 .../tests/integration/routing/conftest.py     |  38 +-
 .../routing/test_motis_adapter_edge_cases.py  |  30 +-
 .../routing/test_motis_adapter_errors.py      |  32 +-
 .../routing/test_motis_adapter_fixture.py     |  34 +-
 .../routing/test_motis_adapter_one_to_all.py  | 162 +++----
 .../routing/test_motis_adapter_online.py      |  39 +-
 .../routing/test_motis_bus_station_buffers.py |  15 +-
 .../unit/routing/test_ab_routing_schemas.py   |  78 ++--
 .../tests/unit/routing/test_base_schemas.py   |  24 +-
 .../tests/unit/routing/test_catchment.py      | 224 ++++++++++
 .../routing/test_catchment_area_transit.py    |  50 +--
 .../unit/routing/test_route_validation.py     |  26 +-
 22 files changed, 1085 insertions(+), 802 deletions(-)
 create mode 100644 packages/python/goatlib/src/goatlib/routing/config.py
 create mode 100644 packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
 create mode 100644 packages/python/goatlib/tests/unit/routing/test_catchment.py

diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
index 8bb81c893..d8b274790 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
@@ -11,7 +11,7 @@
     ABRoutingRequest,
     ABRoutingResponse,
 )
-from goatlib.routing.schemas.base import Location, Mode
+from goatlib.routing.schemas.base import AccessEgressMode, Coordinates, Mode
 from goatlib.routing.schemas.catchment_area_transit import (
     CatchmentAreaPolygon,
     TransitCatchmentAreaRequest,
@@ -228,10 +228,10 @@ def _extract_transport_mode(leg: Dict[str, Any]) -> Mode:
         return MOTIS_TO_INTERNAL_MODE_MAP[motis_mode]
 
     logger.warning(f"Unknown mode {mode_str} in MOTIS leg")
-    return Mode.WALK
+    return Mode.walk
 
 
-def _extract_locations(leg: Dict[str, Any]) -> tuple[Location, Location]:
+def _extract_locations(leg: Dict[str, Any]) -> tuple[Coordinates, Coordinates]:
     """Extract origin and destination locations from MOTIS leg."""
     leg_fields = motis_settings.leg_fields
     location_fields = motis_settings.location_fields
@@ -239,12 +239,12 @@ def _extract_locations(leg: Dict[str, Any]) -> tuple[Location, Location]:
     from_data = leg[leg_fields.from_loc]
     to_data = leg[leg_fields.to_loc]
 
-    origin = Location(
+    origin = Coordinates(
         lat=from_data[location_fields.lat],
         lon=from_data[location_fields.lon],
     )
 
-    destination = Location(
+    destination = Coordinates(
         lat=to_data[location_fields.lat],
         lon=to_data[location_fields.lon],
     )
@@ -289,7 +289,7 @@ def translate_to_motis_one_to_all_request(
     defaults = motis_settings.one_to_all_defaults
 
     # Extract starting point coordinates
-    lat, lon = request.starting_points.latitude[0], request.starting_points.longitude[0]
+    lat, lon = request.starting_points.lat[0], request.starting_points.lon[0]
 
     # Build core parameters
     api_params = {
@@ -324,22 +324,30 @@ def translate_to_motis_one_to_all_request(
         if request.routing_settings.max_transfers:
             api_params[params.max_transfers] = request.routing_settings.max_transfers
 
-        if request.routing_settings.walk_settings:
-            walk_settings = request.routing_settings.walk_settings
-            walk_time_seconds = walk_settings.max_time * 60
-            walk_speed_ms = walk_settings.speed / 3.6  # km/h to m/s
+        # Access settings (pre-transit)
+        if request.routing_settings.access_settings:
+            access = request.routing_settings.access_settings
+            access_time_seconds = access.max_time * 60
+            access_speed_ms = access.speed / 3.6  # km/h to m/s
 
             api_params.update(
                 {
-                    params.max_pre_transit_time: walk_time_seconds,
-                    params.max_post_transit_time: walk_time_seconds,
-                    params.pedestrian_speed: walk_speed_ms,
+                    params.max_pre_transit_time: access_time_seconds,
+                    params.pedestrian_speed: access_speed_ms
+                    if access.mode == AccessEgressMode.walk
+                    else access_speed_ms,
+                    params.cycling_speed: access_speed_ms
+                    if access.mode == AccessEgressMode.bicycle
+                    else None,
                 }
             )
 
-        if request.routing_settings.bike_settings:
-            bike_speed_ms = request.routing_settings.bike_settings.speed / 3.6
-            api_params[params.cycling_speed] = bike_speed_ms
+        # Egress settings (post-transit)
+        if request.routing_settings.egress_settings:
+            egress = request.routing_settings.egress_settings
+            egress_time_seconds = egress.max_time * 60
+
+            api_params[params.max_post_transit_time] = egress_time_seconds
 
     # Add default values
     api_params.update(
@@ -433,6 +441,7 @@ def parse_motis_one_to_all_response(
         ) from e
 
 
+# TODO use catchment class
 def _create_polygon_from_points(
     reachable_locations: List[Dict[str, Any]],
 ) -> Dict[str, Any]:
diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_mappings.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_mappings.py
index cec0d8cac..5d8573fb4 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_mappings.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_mappings.py
@@ -7,79 +7,80 @@
 class MotisMode(StrEnum):
     """MOTIS transport modes enum."""
 
-    WALK = "WALK"
-    BIKE = "BIKE"
-    RENTAL = "RENTAL"
-    CAR = "CAR"
-    CAR_PARKING = "CAR_PARKING"
-    CAR_DROPOFF = "CAR_DROPOFF"
-    ODM = "ODM"
-    FLEX = "FLEX"
-    TRANSIT = "TRANSIT"
-    TRAM = "TRAM"
-    SUBWAY = "SUBWAY"
-    FERRY = "FERRY"
-    AIRPLANE = "AIRPLANE"
-    METRO = "METRO"
-    BUS = "BUS"
-    COACH = "COACH"
-    RAIL = "RAIL"
-    HIGHSPEED_RAIL = "HIGHSPEED_RAIL"
-    LONG_DISTANCE = "LONG_DISTANCE"
-    NIGHT_RAIL = "NIGHT_RAIL"
-    REGIONAL_FAST_RAIL = "REGIONAL_FAST_RAIL"
-    REGIONAL_RAIL = "REGIONAL_RAIL"
-    SUBURBAN = "SUBURBAN"  # S-Bahn/suburban rail
-    CABLE_CAR = "CABLE_CAR"
-    FUNICULAR = "FUNICULAR"
-    AREAL_LIFT = "AREAL_LIFT"
-    OTHER = "OTHER"
+    walk = "WALK"
+    bike = "BIKE"
+    rental = "RENTAL"
+    car = "CAR"
+    car_parking = "CAR_PARKING"
+    car_dropoff = "CAR_DROPOFF"
+    odm = "ODM"
+    flex = "FLEX"
+    transit = "TRANSIT"
+    tram = "TRAM"
+    subway = "SUBWAY"
+    ferry = "FERRY"
+    airplane = "AIRPLANE"
+    metro = "METRO"
+    bus = "BUS"
+    coach = "COACH"
+    rail = "RAIL"
+    highspeed_rail = "HIGHSPEED_RAIL"
+    long_distance = "LONG_DISTANCE"
+    night_rail = "NIGHT_RAIL"
+    regional_fast_rail = "REGIONAL_FAST_RAIL"
+    regional_rail = "REGIONAL_RAIL"
+    suburban = "SUBURBAN"  # S-Bahn/suburban rail
+    cable_car = "CABLE_CAR"
+    funicular = "FUNICULAR"
+    areal_lift = "AREAL_LIFT"
+    other = "OTHER"
 
 
 # Mode mappings between MOTIS and internal representations
 MOTIS_TO_INTERNAL_MODE_MAP = {
     # Active mobility
-    MotisMode.WALK: Mode.WALK,
-    MotisMode.BIKE: Mode.BIKE,
+    MotisMode.walk: Mode.walk,
+    MotisMode.bike: Mode.bicycle,
     # Public transport - Direct mappings
-    MotisMode.BUS: Mode.BUS,
-    MotisMode.COACH: Mode.BUS,  # Coach is a type of bus
-    MotisMode.TRAM: Mode.TRAM,
-    MotisMode.SUBWAY: Mode.SUBWAY,
-    MotisMode.METRO: Mode.SUBWAY,  # Metro is subway
-    MotisMode.FERRY: Mode.FERRY,
-    MotisMode.CABLE_CAR: Mode.CABLE_CAR,
-    MotisMode.FUNICULAR: Mode.FUNICULAR,
+    MotisMode.bus: Mode.bus,
+    MotisMode.coach: Mode.bus,  # Coach is a type of bus
+    MotisMode.tram: Mode.tram,
+    MotisMode.subway: Mode.subway,
+    MotisMode.metro: Mode.subway,  # Metro is subway
+    MotisMode.ferry: Mode.ferry,
+    MotisMode.cable_car: Mode.cable_car,
+    MotisMode.funicular: Mode.funicular,
     # Rail variants - All map to RAIL
-    MotisMode.RAIL: Mode.RAIL,
-    MotisMode.HIGHSPEED_RAIL: Mode.RAIL,
-    MotisMode.LONG_DISTANCE: Mode.RAIL,
-    MotisMode.NIGHT_RAIL: Mode.RAIL,
-    MotisMode.REGIONAL_FAST_RAIL: Mode.RAIL,
-    MotisMode.REGIONAL_RAIL: Mode.RAIL,
-    MotisMode.SUBURBAN: Mode.RAIL,  # S-Bahn/suburban rail
+    MotisMode.rail: Mode.rail,
+    MotisMode.highspeed_rail: Mode.rail,
+    MotisMode.long_distance: Mode.rail,
+    MotisMode.night_rail: Mode.rail,
+    MotisMode.regional_fast_rail: Mode.rail,
+    MotisMode.regional_rail: Mode.rail,
+    MotisMode.suburban: Mode.rail,  # S-Bahn/suburban rail
     # Private transport
-    MotisMode.CAR: Mode.CAR,
-    MotisMode.CAR_PARKING: Mode.CAR,
-    MotisMode.CAR_DROPOFF: Mode.CAR,
+    MotisMode.car: Mode.car,
+    MotisMode.car_parking: Mode.car,
+    MotisMode.car_dropoff: Mode.car,
     # Meta-modes
-    MotisMode.TRANSIT: Mode.TRANSIT,
-    MotisMode.OTHER: Mode.OTHER,
+    MotisMode.transit: Mode.transit,
+    # Note: MotisMode.other maps to transit as a fallback for unknown modes
+    MotisMode.other: Mode.transit,
 }
 
 INTERNAL_TO_MOTIS_MODE_MAP = {
     # Create reverse mapping, handling duplicates by preferring the primary mode
-    Mode.WALK: MotisMode.WALK,
-    Mode.BIKE: MotisMode.BIKE,
-    Mode.BUS: MotisMode.BUS,
-    Mode.TRAM: MotisMode.TRAM,
-    Mode.SUBWAY: MotisMode.SUBWAY,
-    Mode.RAIL: MotisMode.RAIL,
-    Mode.FERRY: MotisMode.FERRY,
-    Mode.CABLE_CAR: MotisMode.CABLE_CAR,
-    Mode.FUNICULAR: MotisMode.FUNICULAR,
-    Mode.CAR: MotisMode.CAR,
-    Mode.TRANSIT: MotisMode.TRANSIT,
+    Mode.walk: MotisMode.walk,
+    Mode.bicycle: MotisMode.bike,
+    Mode.bus: MotisMode.bus,
+    Mode.tram: MotisMode.tram,
+    Mode.subway: MotisMode.subway,
+    Mode.rail: MotisMode.rail,
+    Mode.ferry: MotisMode.ferry,
+    Mode.cable_car: MotisMode.cable_car,
+    Mode.funicular: MotisMode.funicular,
+    Mode.car: MotisMode.car,
+    Mode.transit: MotisMode.transit,
 }
 
 
@@ -89,8 +90,8 @@ def internal_modes_to_motis_string(modes: List[Mode]) -> str:
     string required by the MOTIS API, intelligently handling the TRANSIT category.
 
     Example:
-      [Mode.TRANSIT, Mode.WALK] -> "TRANSIT,WALK" (because MOTIS understands "TRANSIT")
-      [Mode.SUBWAY, Mode.BUS, Mode.WALK] -> "SUBWAY,BUS,WALK"
+      [Mode.transit, Mode.walk] -> "TRANSIT,WALK" (because MOTIS understands "TRANSIT")
+      [Mode.subway, Mode.bus, Mode.walk] -> "SUBWAY,BUS,WALK"
     """
     motis_modes = [INTERNAL_TO_MOTIS_MODE_MAP.get(m) for m in modes]
 
@@ -98,7 +99,7 @@ def internal_modes_to_motis_string(modes: List[Mode]) -> str:
     valid_motis_modes = [m for m in motis_modes if m is not None]
 
     # The MOTIS API itself understands the "TRANSIT" meta-mode. If the user
-    # selected our internal `Mode.TRANSIT`, we should pass "TRANSIT" directly
+    # selected our internal `Mode.transit`, we should pass "TRANSIT" directly
     # to MOTIS rather than expanding it. MOTIS will do the expansion.
     # The only time we need to expand is if our internal logic needs to know
     # the specific modes. The API call does not.
diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_settings.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_settings.py
index a6436aa15..d6ee41bdf 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_settings.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_settings.py
@@ -166,10 +166,10 @@ class Defaults(BaseSettings):
     num_itineraries: int = 5
     max_itineraries: int = 50  # From OpenAPI spec, no explicit default mentioned
     time_is_arrival: bool = False
-    transit_modes: list = [MotisMode.TRANSIT]  # Default allows all transit modes
-    direct_modes: list = [MotisMode.WALK]  # Default walking connections
-    pre_transit_modes: list = [MotisMode.WALK]  # Default pre-transit walking
-    post_transit_modes: list = [MotisMode.WALK]  # Default post-transit walking
+    transit_modes: list = [MotisMode.transit]  # Default allows all transit modes
+    direct_modes: list = [MotisMode.walk]  # Default walking connections
+    pre_transit_modes: list = [MotisMode.walk]  # Default pre-transit walking
+    post_transit_modes: list = [MotisMode.walk]  # Default post-transit walking
     max_transfers: int = 99  # High default as per OpenAPI spec
     search_window: int = 900  # 15 minutes in seconds
     max_matching_distance: int = 25  # 25 meters default
@@ -303,9 +303,9 @@ class OneToAllDefaults(BaseSettings):
     require_car_transport: bool = False  # false = no car transport requirement
     max_pre_transit_time: int = 900  # 15 minutes (900 seconds) to reach transit
     max_post_transit_time: int = 900  # 15 minutes (900 seconds) from transit
-    transit_modes: list = ["TRANSIT"]  # Default all transit modes
-    pre_transit_modes: list = ["WALK"]  # Default walking to transit
-    post_transit_modes: list = ["WALK"]  # Default walking from transit
+    transit_modes: list = [MotisMode.transit]  # Default all transit modes
+    pre_transit_modes: list = [MotisMode.walk]  # Default walking to transit
+    post_transit_modes: list = [MotisMode.walk]  # Default walking from transit
 
 
 # =====================================================================
diff --git a/packages/python/goatlib/src/goatlib/routing/config.py b/packages/python/goatlib/src/goatlib/routing/config.py
new file mode 100644
index 000000000..3332c2f9f
--- /dev/null
+++ b/packages/python/goatlib/src/goatlib/routing/config.py
@@ -0,0 +1,80 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+# --- Nested Models for Configuration ---
+# These models represent the structure of your settings dictionary.
+
+
+class TransitAccessModeLimits(BaseModel):
+    """Configuration for access/egress modes like walking or biking."""
+
+    max_time: int = Field(..., description="Maximum duration in minutes for this mode.")
+    min_speed: float = Field(..., description="Minimum assumed speed in km/h.")
+    max_speed: float = Field(..., description="Maximum assumed speed in km/h.")
+    default_speed: float = Field(..., description="Default assumed speed in km/h.")
+
+
+class TransitLimits(BaseModel):
+    """Configuration specific to transit routing."""
+
+    max_traveltime: int = Field(90, description="Maximum total travel time in minutes.")
+    max_transfers: int = Field(10, description="Maximum number of transfers allowed.")
+
+    walk: TransitAccessModeLimits = TransitAccessModeLimits(
+        max_time=30, min_speed=1.0, max_speed=10.0, default_speed=5.0
+    )
+    bicycle: TransitAccessModeLimits = TransitAccessModeLimits(
+        max_time=45, min_speed=5.0, max_speed=30.0, default_speed=15.0
+    )
+
+
+class ActiveMobilityLimits(BaseModel):
+    """Configuration for active mobility like walking or cycling."""
+
+    max_traveltime: int = Field(45, description="Maximum travel time in minutes.")
+    max_speed: int = Field(25, description="Maximum speed in km/h.")
+
+
+class MotorizedMobilityLimits(BaseModel):
+    """Configuration for private motorized mobility like cars."""
+
+    max_traveltime: int = Field(90, description="Maximum travel time in minutes.")
+    max_speed: Optional[int] = Field(
+        None, description="Maximum speed in km/h (optional)."
+    )
+
+
+class DistanceLimits(BaseModel):
+    """Configuration for distance-based limits."""
+
+    max_distance: int = Field(20000, description="Maximum distance in meters.")
+
+
+# --- The Main BaseSettings Model ---
+
+
+class RoutingSettings(BaseSettings):
+    """
+    Manages all routing limit configurations.
+    Reads from environment variables or uses defaults.
+    """
+
+    # Define the top-level keys from your original dictionary
+    active_mobility: ActiveMobilityLimits = ActiveMobilityLimits()
+    motorized_mobility: MotorizedMobilityLimits = MotorizedMobilityLimits()
+    distance: DistanceLimits = DistanceLimits()
+    transit: TransitLimits = TransitLimits()
+
+    # Configure Pydantic to look for environment variables
+    # e.g., an env var `ROUTING_TRANSIT__MAX_TRANSFERS=5` would override the default.
+    model_config = SettingsConfigDict(
+        env_prefix="ROUTING_",  # A prefix for all environment variables
+        env_nested_delimiter="__",  # Use double underscore for nested objects
+    )
+
+
+# --- Singleton Instance and Legacy Aliases ---
+
+routing_settings = RoutingSettings()
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/ab_routing.py b/packages/python/goatlib/src/goatlib/routing/schemas/ab_routing.py
index 91f86c343..08ce02e16 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/ab_routing.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/ab_routing.py
@@ -6,7 +6,7 @@
 from pydantic import BaseModel, Field, computed_field, model_validator
 
 from goatlib.routing.schemas.base import (
-    Location,
+    Coordinates,
     Mode,
     Route,
     RoutingProvider,
@@ -19,8 +19,8 @@ class ABLeg(BaseModel):
     """Individual leg of an AB route."""
 
     leg_id: str | None = Field(default=None, description="Optional leg identifier")
-    origin: Location = Field(..., description="Starting location of the leg.")
-    destination: Location = Field(..., description="Ending location of the leg.")
+    origin: Coordinates = Field(..., description="Starting Coordinates of the leg.")
+    destination: Coordinates = Field(..., description="Ending Coordinates of the leg.")
     mode: Mode = Field(..., description="Transport mode for this leg.")
     departure_time: datetime = Field(..., description="Departure time of the leg.")
     arrival_time: datetime = Field(..., description="Arrival time of the leg.")
@@ -33,7 +33,7 @@ def get_or_create_id(self: Self) -> str:
         """Get existing ID or create new one if needed."""
         if self.leg_id is None:
             self.leg_id = str(uuid.uuid4())
-        return self.leg_i
+        return self.leg_id
 
     @model_validator(mode="after")
     def validate_leg_times(self: Self) -> Self:
@@ -68,13 +68,13 @@ def validate_route_consistency(self: Self) -> Self:
 class ABRoutingRequest(BaseModel):
     """A-B routing request."""
 
-    origin: Location = Field(..., description="Start location")
-    destination: Location = Field(..., description="End location")
+    origin: Coordinates = Field(..., description="Start Coordinates")
+    destination: Coordinates = Field(..., description="End Coordinates")
     # TODO: set it in the adapter
     provider: RoutingProvider = Field(
-        default=RoutingProvider.MOTIS, description="Routing service provider"
+        default=RoutingProvider.motis, description="Routing service provider"
     )
-    modes: List[Mode] = Field(default=[Mode.WALK])
+    modes: List[Mode] = Field(default=[Mode.walk])
     time: datetime = Field(default=None, description="Departure time")
     # TODO: use it properly
     time_is_arrival: bool = Field(
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/base.py b/packages/python/goatlib/src/goatlib/routing/schemas/base.py
index 88bbb2ca6..f4ce23fc0 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/base.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/base.py
@@ -1,9 +1,6 @@
-# In your_package/schemas/base.py
-
 import uuid
 from datetime import datetime
 from enum import StrEnum
-from typing import List
 
 from pydantic import BaseModel, Field
 
@@ -11,37 +8,53 @@
 class RoutingProvider(StrEnum):
     """Supported routing service providers."""
 
-    MOTIS = "motis"
-    OTP = "otp"
-    R5 = "r5"
+    motis = "motis"
+    otp = "otp"
+    r5 = "r5"
 
 
-class CatchmentAreaType(StrEnum):
-    """Catchment area type schema."""
+class Mode(StrEnum):
+    """Transport mode schema."""
 
-    point = "point"
-    network = "network"
-    grid = "grid"
-    polygon = "polygon"
+    airplane = "airplane"
+    bicycle = "bicycle"
+    bus = "bus"
+    cable_car = "cable_car"
+    car = "car"
+    coach = "coach"
+    ferry = "ferry"
+    flex = "flex"
+    funicular = "funicular"
+    gondola = "gondola"
+    rail = "rail"
+    scooter = "scooter"
+    subway = "subway"
+    tram = "tram"
+    carpool = "carpool"
+    taxi = "taxi"
+    transit = "transit"
+    walk = "walk"
+    trolleybus = "trolleybus"
+    monorail = "monorail"
 
 
 class CatchmentAreaRoutingTypeActiveMobility(StrEnum):
-    """Routing active mobility type schema."""
+    """Active mobility routing mode schema."""
 
-    walking = "walking"
+    walk = "walk"
     wheelchair = "wheelchair"
     bicycle = "bicycle"
     pedelec = "pedelec"
 
 
 class CatchmentAreaRoutingTypeCar(StrEnum):
-    """Routing car type schema."""
+    """Car routing mode schema."""
 
     car = "car"
 
 
 class CatchmentAreaRoutingModePT(StrEnum):
-    """Routing public transport mode schema."""
+    """Public transport routing mode schema."""
 
     bus = "bus"
     tram = "tram"
@@ -60,66 +73,29 @@ class AccessEgressMode(StrEnum):
     bicycle = "bicycle"
 
 
-class Mode(StrEnum):
-    # Active mobility
-    WALK = "walk"
-    BIKE = "bicycle"
-
-    # Public transport
-    TRAM = "tram"
-    SUBWAY = "subway"
-    RAIL = "rail"
-    BUS = "bus"
-    FERRY = "ferry"
-    CABLE_CAR = "cable_car"
-    GONDOLA = "gondola"
-    FUNICULAR = "funicular"
-
-    # Private transport
-    CAR = "car"
-
-    # TODO decide if keep it and define which public transportation modes are included
-    # Meta-modes
-    TRANSIT = "transit"  # Any public transport mode
-    OTHER = "other"  # Fallback for unknown modes
-
-
-# --- Constants for Validation ---
-MAX_SPEEDS_KMH = {
-    Mode.BUS: 120,
-    Mode.TRAM: 80,
-    Mode.SUBWAY: 120,
-    Mode.RAIL: 400,
-}
-DEFAULT_MAX_SPEED_KMH = 250
-
-
-class Location(BaseModel):
-    """Geographic location using WGS84 coordinates."""
+class CatchmentAreaType(StrEnum):
+    """Area analysis type schema."""
 
-    lat: float = Field(..., description="Latitude", ge=-90.0, le=90.0)
-    lon: float = Field(..., description="Longitude", ge=-180.0, le=180.0)
+    point = "point"
+    network = "network"
+    grid = "grid"
+    polygon = "polygon"
 
 
-class Route(BaseModel):
-    """Base model for a route."""
+class Coordinates(BaseModel):
+    """Standard geographic location with WGS84 coordinates."""
 
-    route_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
-    distance: float = Field(..., description="Distance in meters", ge=0)
-    duration: float = Field(..., description="Duration in seconds", ge=0)
-    departure_time: datetime = Field(..., description="Departure time")
+    lat: float = Field(..., description="Latitude", ge=-90.0, le=90.0)
+    lon: float = Field(..., description="Longitude", ge=-180.0, le=180.0)
 
 
-class CatchmentAreaStartingPoints(BaseModel):
-    """Base model for catchment area attributes."""
+class Route(BaseModel):
+    """Base route model with common routing attributes."""
 
-    latitude: List[float] | None = Field(
-        None,
-        title="Latitude",
-        description="The latitude of the catchment area center.",
-    )
-    longitude: List[float] | None = Field(
-        None,
-        title="Longitude",
-        description="The longitude of the catchment area center.",
+    route_id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()), description="Unique route identifier"
     )
+    duration: float = Field(..., description="Total duration in seconds", ge=0)
+    distance: float | None = Field(None, description="Total distance in meters", ge=0)
+    departure_time: datetime = Field(..., description="Route departure time")
+    arrival_time: datetime | None = Field(None, description="Route arrival time")
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py b/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
new file mode 100644
index 000000000..c117fe53a
--- /dev/null
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
@@ -0,0 +1,55 @@
+from typing import List
+
+from pydantic import BaseModel, Field, field_validator
+
+from goatlib.routing.schemas.base import (
+    CatchmentAreaType,
+    Coordinates,
+)
+
+
+class CatchmentSchema(BaseModel):
+    """Schema for catchment area requests."""
+
+    starting_points: List[Coordinates] = Field(
+        ...,
+        title="Starting Points",
+        description="List of geographic Coordinates for catchment calculation starting points.",
+        min_length=1,
+    )
+
+    cutoffs: List[float] = Field(
+        ...,
+        title="Cutoffs",
+        description="List of cost thresholds for catchment area calculation (time in minutes or distance in meters).",
+        min_length=1,
+        max_length=10,
+    )
+
+    type: CatchmentAreaType = Field(
+        ...,
+        title="Area Type",
+        description="The type of catchment area output to generate.",
+    )
+
+    @field_validator("cutoffs")
+    @classmethod
+    def validate_cutoffs(cls, v: List[float]) -> List[float]:
+        """Validate that cutoffs are positive and in ascending order."""
+        for i, cutoff in enumerate(v):
+            if cutoff <= 0:
+                raise ValueError(f"Cutoff {i} must be positive, got {cutoff}")
+
+        # Ensure cutoffs are in ascending order
+        if all(v[i] <= v[i + 1] for i in range(len(v) - 1)):
+            return v
+        v.sort()
+        return v
+
+
+# Example usage
+example_catchment = {
+    "starting_points": [{"lon": 11.123, "lat": 12.34}, {"lon": 48.11, "lat": 48.1234}],
+    "cutoffs": [10.0, 20.0, 30.0],
+    "type": "polygon",
+}
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_active.py b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_active.py
index 5d18266fd..02ed76799 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_active.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_active.py
@@ -1,86 +1,55 @@
-from typing import Any, Optional, Self
+from typing import Any, Literal, Optional, Self, Union
 from uuid import UUID
 
 from pydantic import BaseModel, Field, field_validator, model_validator
-from routing.core.config import settings
 
+from goatlib.routing.config import routing_settings
 from goatlib.routing.schemas.base import (
     CatchmentAreaRoutingTypeActiveMobility,
     CatchmentAreaRoutingTypeCar,
-    CatchmentAreaStartingPoints,
     CatchmentAreaType,
+    Coordinates,
 )
 
 
-class _BaseTravelTimeCost(BaseModel):
-    """Internal base schema for travel time cost."""
-
-    max_traveltime: int
-
-    steps: int = Field(
-        ...,
-        title="Steps",
-        description="The number of steps.",
-    )
-
-    # This validator is now generic
-    @field_validator("steps")
-    @classmethod
-    def valid_num_steps(cls, v: int) -> int:
-        """
-        Validate that the number of steps does not exceed the `le` constraint
-        defined on the `max_traveltime` field for this specific model.
-        """
-        # Dynamically get the 'le' value from the max_traveltime field definition
-        max_traveltime_limit = cls.model_fields["max_traveltime"].le
-
-        if max_traveltime_limit is None:
-            # Failsafe in case 'le' is not set on the field
-            return v
-
-        if v > max_traveltime_limit:
-            raise ValueError(
-                f"The number of steps ({v}) must not exceed the maximum travel time ({max_traveltime_limit})."
-            )
-        return v
-
-
-class CatchmentAreaTravelTimeCostActiveMobility(_BaseTravelTimeCost):
-    """Travel time cost schema for active mobility."""
+class TravelTimeCost(BaseModel):
+    """Travel time-based cost schema."""
 
+    cost_type: Literal["time"] = "time"
     max_traveltime: int = Field(
         ...,
         title="Max Travel Time",
         description="The maximum travel time in minutes.",
         ge=1,
-        le=45,
     )
-
-    speed: int = Field(
+    steps: int = Field(
         ...,
+        title="Steps",
+        description="The number of steps.",
+    )
+    speed: Optional[int] = Field(
+        None,
         title="Speed",
         description="The speed in km/h.",
         ge=1,
-        le=25,
     )
 
-
-class CatchmentAreaTravelTimeCostMotorizedMobility(_BaseTravelTimeCost):
-    """Travel time cost schema for motorized mobility."""
-
-    max_traveltime: int = Field(
-        ...,
-        title="Max Travel Time",
-        description="The maximum travel time in minutes.",
-        ge=1,
-        le=90,
-    )
+    @field_validator("steps")
+    @classmethod
+    def validate_steps(cls, v: int, info) -> int:
+        """Validate steps don't exceed max_traveltime."""
+        max_traveltime = info.data.get("max_traveltime")
+        if max_traveltime and v > max_traveltime:
+            raise ValueError(
+                f"Steps ({v}) cannot exceed max travel time ({max_traveltime})."
+            )
+        return v
 
 
-# TODO: Check how to treat miles
-class CatchmentAreaTravelDistanceCost(BaseModel):
-    """Travel distance cost schema, applicable to any mobility type."""
+class TravelDistanceCost(BaseModel):
+    """Travel distance-based cost schema."""
 
+    cost_type: Literal["distance"] = "distance"
     max_distance: int = Field(
         ...,
         title="Max Distance",
@@ -96,30 +65,22 @@ class CatchmentAreaTravelDistanceCost(BaseModel):
 
     @field_validator("steps")
     @classmethod
-    def valid_num_steps(cls, v: int) -> int:
-        """
-        Validate that the number of steps does not exceed the `le` constraint
-        defined on the `max_distance` field.
-        """
-        max_distance_limit = cls.model_fields["max_distance"].le
-
-        if max_distance_limit is None:
-            return v  # Failsafe
-
-        if v > max_distance_limit:
+    def validate_steps(cls, v: int, info) -> int:
+        """Validate steps don't exceed max_distance."""
+        max_distance = info.data.get("max_distance")
+        if max_distance and v > max_distance:
             raise ValueError(
-                f"The number of steps ({v}) must not exceed the maximum distance ({max_distance_limit})."
+                f"Steps ({v}) cannot exceed max distance ({max_distance})."
             )
         return v
 
 
+# Union type for travel costs
+TravelCost = Union[TravelTimeCost, TravelDistanceCost]
+
+
 class CatchmentAreaStreetNetwork(BaseModel):
-    def __init__(self, **data: Any) -> None:
-        super().__init__(**data)
-        if self.node_layer_project_id is None:
-            self.node_layer_project_id = (
-                settings.DEFAULT_STREET_NETWORK_NODE_LAYER_PROJECT_ID
-            )
+    """Street network configuration for catchment area analysis."""
 
     edge_layer_project_id: int = Field(
         ...,
@@ -132,101 +93,126 @@ def __init__(self, **data: Any) -> None:
         description="The layer project ID of the street network node layer.",
     )
 
+    def __init__(self, **data: Any) -> None:
+        super().__init__(**data)
+        if self.node_layer_project_id is None:
+            self.node_layer_project_id = (
+                routing_settings.default_street_network_node_layer_project_id
+            )
+
 
-class _BaseICatchmentArea(BaseModel):
-    """Internal base model for all catchment area requests."""
+class CatchmentAreaRequest(BaseModel):
+    """Unified catchment area request model."""
 
-    starting_points: CatchmentAreaStartingPoints = Field(
+    starting_points: list[Coordinates] = Field(
         ...,
         title="Starting Points",
         description="The starting points of the catchment area.",
     )
-    scenario_id: UUID | None = Field(
-        None,
-        title="Scenario ID",
-        description="The ID of the scenario that is to be applied on the base network.",
+    routing_type: Union[
+        CatchmentAreaRoutingTypeActiveMobility, CatchmentAreaRoutingTypeCar
+    ] = Field(
+        ..., title="Routing Type", description="The routing type of the catchment area."
     )
-    street_network: CatchmentAreaStreetNetwork | None = Field(
-        None,
-        title="Street Network Layer Config",
-        description="The configuration of the street network layers to use.",
+    travel_cost: TravelCost = Field(
+        ..., title="Travel Cost", description="The travel cost configuration."
     )
     catchment_area_type: CatchmentAreaType = Field(
         ..., title="Return Type", description="The return type of the catchment area."
     )
-    polygon_difference: bool | None = Field(
-        None,
-        title="Polygon Difference",
-        description="If true, the polygons returned will be the geometrical difference of two following calculations.",
-    )
     result_table: str = Field(
         ...,
         title="Result Table",
         description="The table name the results should be saved.",
     )
-    layer_id: UUID | None = Field(
+    layer_id: UUID = Field(
         ...,
         title="Layer ID",
         description="The ID of the layer the results should be saved.",
     )
-
-    routing_type: str
-    travel_cost: Any
+    scenario_id: Optional[UUID] = Field(
+        None,
+        title="Scenario ID",
+        description="The ID of the scenario that is to be applied on the base network.",
+    )
+    street_network: Optional[CatchmentAreaStreetNetwork] = Field(
+        None,
+        title="Street Network Layer Config",
+        description="The configuration of the street network layers to use.",
+    )
+    polygon_difference: Optional[bool] = Field(
+        None,
+        title="Polygon Difference",
+        description="If true, the polygons returned will be the geometrical difference of two following calculations.",
+    )
 
     @model_validator(mode="after")
-    def _model_validator(self) -> Self:
-        scenario_id = self.scenario_id
-        street_network = self.street_network
-        polygon_difference = self.polygon_difference
-        catchment_area_type = self.catchment_area_type
-        # Ensure street network is specified if a scenario ID is provided
-        if scenario_id is not None and street_network is None:
+    def validate_configuration(self) -> Self:
+        """Validate the overall configuration consistency."""
+        # Validate scenario + street network relationship
+        if self.scenario_id is not None and self.street_network is None:
             raise ValueError(
-                "The street network must be set if a scenario ID is provided."
+                "Street network must be specified when using a scenario ID."
             )
-        # Check that polygon difference exists if catchment area type is polygon
-        if (
-            catchment_area_type == CatchmentAreaType.polygon.value
-            and polygon_difference is None
-        ):
+
+        # Validate polygon difference settings
+        is_polygon = self.catchment_area_type == CatchmentAreaType.polygon
+        if is_polygon and self.polygon_difference is None:
             raise ValueError(
-                "The polygon difference must be set if the catchment area type is polygon."
+                "Polygon difference must be specified for polygon catchment areas."
             )
-        # Check that polygon difference is not specified if catchment area type is not polygon
-        if (
-            catchment_area_type != CatchmentAreaType.polygon.value
-            and polygon_difference is not None
-        ):
+        elif not is_polygon and self.polygon_difference is not None:
             raise ValueError(
-                "The polygon difference must not be set if the catchment area type is not polygon."
+                "Polygon difference should not be specified for non-polygon catchment areas."
             )
-        return self
-
-
-class ICatchmentAreaActiveMobility(_BaseICatchmentArea):
-    """Model for the active mobility catchment area request."""
 
-    routing_type: CatchmentAreaRoutingTypeActiveMobility = Field(
-        ..., title="Routing Type", description="The routing type of the catchment area."
-    )
-    travel_cost: (
-        CatchmentAreaTravelTimeCostActiveMobility | CatchmentAreaTravelDistanceCost
-    ) = Field(
-        ..., title="Travel Cost", description="The travel cost of the catchment area."
-    )
+        # Validate routing type and travel cost constraints
+        self._validate_routing_constraints()
 
+        return self
 
-class ICatchmentAreaCar(_BaseICatchmentArea):
-    """Model for the car catchment area request."""
-
-    routing_type: CatchmentAreaRoutingTypeCar = Field(
-        ..., title="Routing Type", description="The routing type of the catchment area."
-    )
-    travel_cost: (
-        CatchmentAreaTravelTimeCostMotorizedMobility | CatchmentAreaTravelDistanceCost
-    ) = Field(
-        ..., title="Travel Cost", description="The travel cost of the catchment area."
-    )
+    def _validate_routing_constraints(self) -> None:
+        """Validate routing type specific constraints."""
+        # For active mobility, enforce speed requirements and limits
+        if isinstance(self.routing_type, CatchmentAreaRoutingTypeActiveMobility):
+            if isinstance(self.travel_cost, TravelTimeCost):
+                if self.travel_cost.speed is None:
+                    raise ValueError(
+                        "Speed is required for active mobility time-based routing."
+                    )
+                if self.travel_cost.speed > routing_settings.active_mobility.max_speed:
+                    raise ValueError(
+                        f"Speed ({self.travel_cost.speed}) exceeds maximum for active mobility "
+                        f"({routing_settings.active_mobility.max_speed})."
+                    )
+                if (
+                    self.travel_cost.max_traveltime
+                    > routing_settings.active_mobility.max_traveltime
+                ):
+                    raise ValueError(
+                        f"Travel time ({self.travel_cost.max_traveltime}) exceeds maximum for active mobility "
+                        f"({routing_settings.active_mobility.max_traveltime})."
+                    )
+
+        # For car routing, enforce travel time limits
+        elif isinstance(self.routing_type, CatchmentAreaRoutingTypeCar):
+            if isinstance(self.travel_cost, TravelTimeCost):
+                if (
+                    self.travel_cost.max_traveltime
+                    > routing_settings.motorized_mobility_limits["max_traveltime"]
+                ):
+                    raise ValueError(
+                        f"Travel time ({self.travel_cost.max_traveltime}) exceeds maximum for motorized mobility "
+                        f"({routing_settings.motorized_mobility_limits['max_traveltime']})."
+                    )
+                # Speed is optional for cars
+                if self.travel_cost.speed is not None and self.travel_cost.speed <= 0:
+                    raise ValueError("Speed must be positive if specified.")
+
+
+# Backward compatibility aliases
+ICatchmentAreaActiveMobility = CatchmentAreaRequest
+ICatchmentAreaCar = CatchmentAreaRequest
 
 
 request_examples: dict[str, Any] = {
@@ -235,9 +221,10 @@ class ICatchmentAreaCar(_BaseICatchmentArea):
         "single_point_walking_time": {
             "summary": "Single point catchment area walking (time based)",
             "value": {
-                "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+                "starting_points": [{"lat": 52.5200, "lon": 13.4050}],
                 "routing_type": "walking",
                 "travel_cost": {
+                    "cost_type": "time",
                     "max_traveltime": 30,
                     "steps": 5,
                     "speed": 5,
@@ -252,9 +239,10 @@ class ICatchmentAreaCar(_BaseICatchmentArea):
         "single_point_walking_distance": {
             "summary": "Single point catchment area walking (distance based)",
             "value": {
-                "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+                "starting_points": [{"lat": 52.5200, "lon": 13.4050}],
                 "routing_type": "walking",
                 "travel_cost": {
+                    "cost_type": "distance",
                     "max_distance": 2500,
                     "steps": 100,
                 },
@@ -268,9 +256,10 @@ class ICatchmentAreaCar(_BaseICatchmentArea):
         "single_point_cycling": {
             "summary": "Single point catchment area cycling",
             "value": {
-                "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+                "starting_points": [{"lat": 52.5200, "lon": 13.4050}],
                 "routing_type": "bicycle",
                 "travel_cost": {
+                    "cost_type": "time",
                     "max_traveltime": 15,
                     "steps": 5,
                     "speed": 15,
@@ -283,11 +272,12 @@ class ICatchmentAreaCar(_BaseICatchmentArea):
         },
         # 4. Single catchment area for walking with scenario
         "single_point_walking_scenario": {
-            "summary": "Single point catchment area walking",
+            "summary": "Single point catchment area walking with scenario",
             "value": {
-                "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+                "starting_points": [{"lat": 52.5200, "lon": 13.4050}],
                 "routing_type": "walking",
                 "travel_cost": {
+                    "cost_type": "time",
                     "max_traveltime": 30,
                     "steps": 10,
                     "speed": 5,
@@ -303,34 +293,21 @@ class ICatchmentAreaCar(_BaseICatchmentArea):
         "multi_point_walking": {
             "summary": "Multi point catchment area walking",
             "value": {
-                "starting_points": {
-                    "latitude": [
-                        52.5200,
-                        52.5210,
-                        52.5220,
-                        52.5230,
-                        52.5240,
-                        52.5250,
-                        52.5260,
-                        52.5270,
-                        52.5280,
-                        52.5290,
-                    ],
-                    "longitude": [
-                        13.4050,
-                        13.4060,
-                        13.4070,
-                        13.4080,
-                        13.4090,
-                        13.4100,
-                        13.4110,
-                        13.4120,
-                        13.4130,
-                        13.4140,
-                    ],
-                },
+                "starting_points": [
+                    {"lat": 52.5200, "lon": 13.4050},
+                    {"lat": 52.5210, "lon": 13.4060},
+                    {"lat": 52.5220, "lon": 13.4070},
+                    {"lat": 52.5230, "lon": 13.4080},
+                    {"lat": 52.5240, "lon": 13.4090},
+                    {"lat": 52.5250, "lon": 13.4100},
+                    {"lat": 52.5260, "lon": 13.4110},
+                    {"lat": 52.5270, "lon": 13.4120},
+                    {"lat": 52.5280, "lon": 13.4130},
+                    {"lat": 52.5290, "lon": 13.4140},
+                ],
                 "routing_type": "walking",
                 "travel_cost": {
+                    "cost_type": "time",
                     "max_traveltime": 30,
                     "steps": 10,
                     "speed": 5,
@@ -345,34 +322,21 @@ class ICatchmentAreaCar(_BaseICatchmentArea):
         "multi_point_cycling": {
             "summary": "Multi point catchment area cycling",
             "value": {
-                "starting_points": {
-                    "latitude": [
-                        52.5200,
-                        52.5210,
-                        52.5220,
-                        52.5230,
-                        52.5240,
-                        52.5250,
-                        52.5260,
-                        52.5270,
-                        52.5280,
-                        52.5290,
-                    ],
-                    "longitude": [
-                        13.4050,
-                        13.4060,
-                        13.4070,
-                        13.4080,
-                        13.4090,
-                        13.4100,
-                        13.4110,
-                        13.4120,
-                        13.4130,
-                        13.4140,
-                    ],
-                },
+                "starting_points": [
+                    {"lat": 52.5200, "lon": 13.4050},
+                    {"lat": 52.5210, "lon": 13.4060},
+                    {"lat": 52.5220, "lon": 13.4070},
+                    {"lat": 52.5230, "lon": 13.4080},
+                    {"lat": 52.5240, "lon": 13.4090},
+                    {"lat": 52.5250, "lon": 13.4100},
+                    {"lat": 52.5260, "lon": 13.4110},
+                    {"lat": 52.5270, "lon": 13.4120},
+                    {"lat": 52.5280, "lon": 13.4130},
+                    {"lat": 52.5290, "lon": 13.4140},
+                ],
                 "routing_type": "bicycle",
                 "travel_cost": {
+                    "cost_type": "time",
                     "max_traveltime": 15,
                     "steps": 5,
                     "speed": 15,
@@ -389,9 +353,10 @@ class ICatchmentAreaCar(_BaseICatchmentArea):
         "single_point_car_time": {
             "summary": "Single point catchment area car (time based)",
             "value": {
-                "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+                "starting_points": [{"lat": 52.5200, "lon": 13.4050}],
                 "routing_type": "car",
                 "travel_cost": {
+                    "cost_type": "time",
                     "max_traveltime": 30,
                     "steps": 5,
                 },
@@ -405,9 +370,10 @@ class ICatchmentAreaCar(_BaseICatchmentArea):
         "single_point_car_distance": {
             "summary": "Single point catchment area car (distance based)",
             "value": {
-                "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+                "starting_points": [{"lat": 52.5200, "lon": 13.4050}],
                 "routing_type": "car",
                 "travel_cost": {
+                    "cost_type": "distance",
                     "max_distance": 10000,
                     "steps": 100,
                 },
@@ -419,11 +385,12 @@ class ICatchmentAreaCar(_BaseICatchmentArea):
         },
         # 3. Single catchment area for car with scenario
         "single_point_car_scenario": {
-            "summary": "Single point catchment area car",
+            "summary": "Single point catchment area car with scenario",
             "value": {
-                "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+                "starting_points": [{"lat": 52.5200, "lon": 13.4050}],
                 "routing_type": "car",
                 "travel_cost": {
+                    "cost_type": "time",
                     "max_traveltime": 30,
                     "steps": 10,
                 },
@@ -438,34 +405,21 @@ class ICatchmentAreaCar(_BaseICatchmentArea):
         "multi_point_car": {
             "summary": "Multi point catchment area car",
             "value": {
-                "starting_points": {
-                    "latitude": [
-                        52.5200,
-                        52.5210,
-                        52.5220,
-                        52.5230,
-                        52.5240,
-                        52.5250,
-                        52.5260,
-                        52.5270,
-                        52.5280,
-                        52.5290,
-                    ],
-                    "longitude": [
-                        13.4050,
-                        13.4060,
-                        13.4070,
-                        13.4080,
-                        13.4090,
-                        13.4100,
-                        13.4110,
-                        13.4120,
-                        13.4130,
-                        13.4140,
-                    ],
-                },
+                "starting_points": [
+                    {"lat": 52.5200, "lon": 13.4050},
+                    {"lat": 52.5210, "lon": 13.4060},
+                    {"lat": 52.5220, "lon": 13.4070},
+                    {"lat": 52.5230, "lon": 13.4080},
+                    {"lat": 52.5240, "lon": 13.4090},
+                    {"lat": 52.5250, "lon": 13.4100},
+                    {"lat": 52.5260, "lon": 13.4110},
+                    {"lat": 52.5270, "lon": 13.4120},
+                    {"lat": 52.5280, "lon": 13.4130},
+                    {"lat": 52.5290, "lon": 13.4140},
+                ],
                 "routing_type": "car",
                 "travel_cost": {
+                    "cost_type": "time",
                     "max_traveltime": 30,
                     "steps": 10,
                 },
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
index 09ac14d24..f07564062 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
@@ -3,154 +3,214 @@
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
+from goatlib.routing.config import routing_settings
 from goatlib.routing.schemas.base import (
     AccessEgressMode,
     CatchmentAreaRoutingModePT,
-    CatchmentAreaStartingPoints,
 )
 
 
-class TransitCatchmentAreaStartingPoints(CatchmentAreaStartingPoints):
-    """Transit CatchmentArea starting points with single-point constraint."""
+class CatchmentAreaStartingPointsPT(BaseModel):
+    """Starting points for transit catchment areas (single point only)."""
+
+    lat: List[float] = Field(
+        ..., description="List of latitudes (must contain exactly one point)."
+    )
+    lon: List[float] = Field(
+        ..., description="List of longitudes (must contain exactly one point)."
+    )
 
     @model_validator(mode="after")
-    def validate_transit_constraints(
-        self: "TransitCatchmentAreaStartingPoints",
-    ) -> "TransitCatchmentAreaStartingPoints":
-        """Ensure single starting point for transit CatchmentAreas."""
-        if self.latitude and len(self.latitude) > 1:
+    def validate_single_point(self) -> Self:
+        """Ensure exactly one starting point for transit routing."""
+        if not self.lat or not self.lon:
+            raise ValueError("Latitude and longitude are required for transit routing.")
+
+        if len(self.lat) != 1 or len(self.lon) != 1:
             raise ValueError(
-                "Transit CatchmentAreas support only single starting point."
+                "Transit catchment areas support exactly one starting point."
             )
-        return self
-
 
-"""Travel time configuration """
+        return self
 
 
-class TransitCatchmentAreaTravelTimeCost(BaseModel):
-    """Travel time configuration for transit CatchmentAreas with cutoffs instead of steps."""
+class TravelTimeCost(BaseModel):
+    """Travel time configuration with cutoffs for transit analysis."""
 
     max_traveltime: int = Field(
         ...,
         title="Max Travel Time",
         description="The maximum travel time in minutes.",
         ge=1,
-        le=90,
+        le=routing_settings.transit.max_traveltime,
     )
-
     cutoffs: List[int] = Field(
         ...,
         title="Time Cutoffs",
-        description="List of travel time cutoffs in minutes for CatchmentArea bands.",
+        description="List of travel time cutoffs in minutes for catchment area bands.",
         min_length=1,
     )
 
     @model_validator(mode="after")
-    def validate_cutoffs_against_max_time(self) -> Self:
-        """Validate that cutoffs are within max_traveltime and sorted."""
-        max_time = self.max_traveltime
-        for cutoff in self.cutoffs:
-            if cutoff > max_time:
-                raise ValueError(
-                    f"Cutoff {cutoff} exceeds maximum travel time {max_time}."
-                )
-
-        if not all(c > 0 for c in self.cutoffs):
+    def validate_cutoffs(self) -> Self:
+        """Validate that cutoffs are within max_traveltime and properly ordered."""
+        # Check cutoffs are within max time
+        invalid_cutoffs = [c for c in self.cutoffs if c > self.max_traveltime]
+        if invalid_cutoffs:
+            raise ValueError(
+                f"Cutoffs {invalid_cutoffs} exceed maximum travel time {self.max_traveltime}."
+            )
+
+        # Check all cutoffs are positive
+        if any(c <= 0 for c in self.cutoffs):
             raise ValueError("All cutoffs must be positive.")
 
-        if self.cutoffs != sorted(list(set(self.cutoffs))):
+        # Check cutoffs are unique and sorted
+        unique_sorted = sorted(set(self.cutoffs))
+        if self.cutoffs != unique_sorted:
             raise ValueError("Cutoffs must be unique and in ascending order.")
 
         return self
 
 
-class _ActiveMobilitySettings(BaseModel):
-    """Base configuration for an active mobility leg of a journey."""
-
-    max_time: int
-    speed: float
-
-
-class WalkSettings(_ActiveMobilitySettings):
-    """Configuration for walking legs of the journey."""
-
-    max_time: int = Field(15, title="Maximum Walk Time (minutes)", ge=1, le=30)
+class AccessEgressSettings(BaseModel):
+    """Settings for access/egress modes in transit routing."""
 
+    mode: AccessEgressMode = Field(
+        default=AccessEgressMode.walk,
+        title="Access/Egress Mode",
+        description="Mode of transportation for access or egress.",
+    )
+    max_time: int = Field(
+        ...,
+        title="Maximum Time",
+        description="Maximum time allowed for this mode in minutes.",
+        ge=1,
+    )
     speed: float = Field(
-        5.0,
-        title="Walking Speed (km/h)",
-        description="Average walking speed in kilometers per hour.",
-        ge=1.0,
-        le=10.0,
+        ...,
+        title="Speed",
+        description="Average speed for this mode in km/h.",
+        gt=0,
     )
 
+    @model_validator(mode="after")
+    def validate_mode_constraints(self) -> Self:
+        """Validate constraints based on the access/egress mode."""
+        mode_key = self.mode.value
+        limits = getattr(routing_settings.transit, mode_key, None)
+        if not limits:
+            raise ValueError(f"Unknown access/egress mode: {self.mode}")
+
+        # Validate time limits
+        if self.max_time > limits.max_time:
+            raise ValueError(
+                f"Max time ({self.max_time}) exceeds limit for {self.mode} ({limits.max_time})."
+            )
 
-class BikeSettings(_ActiveMobilitySettings):
-    """Configuration for biking legs of the journey."""
-
-    max_time: int = Field(20, title="Maximum Bike Time (minutes)", ge=1, le=45)
-
-    speed: float = Field(
-        15.0,
-        title="Biking Speed (km/h)",
-        description="Average biking speed in kilometers per hour.",
-        ge=5.0,
-        le=30.0,
-    )
+        # Validate speed limits
+        if not (limits.min_speed <= self.speed <= limits.max_speed):
+            raise ValueError(
+                f"Speed ({self.speed}) must be between {limits.min_speed} and {limits.max_speed} for {self.mode}."
+            )
 
+        return self
 
-class TransitRoutingSettings(BaseModel):
-    """Advanced tuning parameters for the transit routing algorithm."""
+    @classmethod
+    def create_walk_settings(
+        cls, max_time: int = 15, speed: float = None
+    ) -> "AccessEgressSettings":
+        """Create walk settings with defaults."""
+        return cls(
+            mode=AccessEgressMode.walk,
+            max_time=max_time,
+            speed=speed or routing_settings.transit.walk.default_speed,
+        )
 
-    max_transfers: int = Field(4, title="Maximum Transfers", ge=0, le=10)
-    walk_settings: WalkSettings = Field(default_factory=WalkSettings)
-    bike_settings: BikeSettings = Field(default_factory=BikeSettings)
+    @classmethod
+    def create_bike_settings(
+        cls, max_time: int = 20, speed: float = None
+    ) -> "AccessEgressSettings":
+        """Create bike settings with defaults."""
+        return cls(
+            mode=AccessEgressMode.bicycle,
+            max_time=max_time,
+            speed=speed or routing_settings.transit.bicycle.default_speed,
+        )
 
 
-"""Main request schema."""
+class TransitRoutingSettings(BaseModel):
+    """Advanced configuration for transit routing algorithm."""
+
+    max_transfers: int = Field(
+        default=4,
+        title="Maximum Transfers",
+        description="Maximum number of transfers allowed.",
+        ge=0,
+        le=routing_settings.transit.max_transfers,
+    )
+    access_settings: AccessEgressSettings = Field(
+        default_factory=AccessEgressSettings.create_walk_settings,
+        title="Access Settings",
+        description="Configuration for accessing transit stops.",
+    )
+    egress_settings: AccessEgressSettings = Field(
+        default_factory=AccessEgressSettings.create_walk_settings,
+        title="Egress Settings",
+        description="Configuration for egressing from transit stops.",
+    )
 
 
 class TransitCatchmentAreaRequest(BaseModel):
-    """Request model for transit CatchmentArea calculation."""
+    """Unified request model for transit catchment area calculation."""
 
-    starting_points: TransitCatchmentAreaStartingPoints = Field(
+    starting_points: CatchmentAreaStartingPointsPT = Field(
         ...,
         title="Starting Points",
-        description="Starting points for CatchmentArea calculation.",
+        description="Starting point for catchment area calculation (single point only).",
     )
     transit_modes: List[CatchmentAreaRoutingModePT] = Field(
         ...,
         title="Transit Modes",
-        description="List of transit modes to include in the CatchmentArea calculation.",
+        description="List of transit modes to include in the calculation.",
         min_length=1,
     )
-    access_mode: AccessEgressMode = Field(
-        default=AccessEgressMode.walk,
-        title="Access Mode",
-        description="Mode of transportation to access transit stops.",
-    )
-    egress_mode: AccessEgressMode = Field(
-        default=AccessEgressMode.walk,
-        title="Egress Mode",
-        description="Mode of transportation from transit stops to destination.",
-    )
-    travel_cost: TransitCatchmentAreaTravelTimeCost = Field(
+    travel_cost: TravelTimeCost = Field(
         ...,
         title="Travel Cost Configuration",
         description="Travel time and cutoff configuration.",
     )
+    routing_settings: TransitRoutingSettings = Field(
+        default_factory=TransitRoutingSettings,
+        title="Routing Settings",
+        description="Advanced routing configuration.",
+    )
     network_id: Optional[UUID] = Field(
         default=None,
         title="Network ID",
-        description="Optional ID of the transit network to use for routing calculations.",
+        description="Optional ID of the transit network to use.",
     )
 
-    routing_settings: TransitRoutingSettings = Field(
-        default_factory=TransitRoutingSettings,
-        title="Routing Settings",
-        description="Advanced routing settings.",
-    )
+    # Convenience properties for backward compatibility
+    @property
+    def access_mode(self) -> AccessEgressMode:
+        """Get the access mode for backward compatibility."""
+        return self.routing_settings.access_settings.mode
+
+    @property
+    def egress_mode(self) -> AccessEgressMode:
+        """Get the egress mode for backward compatibility."""
+        return self.routing_settings.egress_settings.mode
+
+    @property
+    def max_transfers(self) -> int:
+        """Get max transfers for backward compatibility."""
+        return self.routing_settings.max_transfers
+
+
+# Backward compatibility aliases
+TransitCatchmentAreaStartingPoints = CatchmentAreaStartingPointsPT
+TransitCatchmentAreaTravelTimeCost = TravelTimeCost
 
 
 """Response schemas."""
@@ -212,7 +272,7 @@ class TransitCatchmentAreaResponse(BaseModel):
     "basic_transit_catchment_area": {
         "summary": "basic transit catchment area request",
         "value": {
-            "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+            "starting_points": {"lat": [52.5200], "lon": [13.4050]},
             "transit_modes": ["bus", "tram", "subway"],
             "travel_cost": {"max_traveltime": 60, "cutoffs": [15, 30, 45, 60]},
         },
@@ -220,7 +280,7 @@ class TransitCatchmentAreaResponse(BaseModel):
     "bike_access_catchment_area": {
         "summary": "bike access catchment area request",
         "value": {
-            "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+            "starting_points": {"lat": [52.5200], "lon": [13.4050]},
             "transit_modes": ["rail", "subway"],
             "access_mode": "bicycle",
             "travel_cost": {"max_traveltime": 45, "cutoffs": [15, 30, 45]},
@@ -230,7 +290,7 @@ class TransitCatchmentAreaResponse(BaseModel):
     "custom_speeds_catchment_area": {
         "summary": "custom speeds catchment area request",
         "value": {
-            "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+            "starting_points": {"lat": [52.5200], "lon": [13.4050]},
             "transit_modes": ["bus", "tram"],
             "egress_mode": "bicycle",
             "travel_cost": {"max_traveltime": 50, "cutoffs": [10, 20, 30, 40, 50]},
diff --git a/packages/python/goatlib/src/goatlib/routing/utils/ab_route_validator.py b/packages/python/goatlib/src/goatlib/routing/utils/ab_route_validator.py
index 4033977fc..d25fef0a9 100644
--- a/packages/python/goatlib/src/goatlib/routing/utils/ab_route_validator.py
+++ b/packages/python/goatlib/src/goatlib/routing/utils/ab_route_validator.py
@@ -2,7 +2,7 @@
 from typing import Dict, List, Optional, Tuple
 
 from goatlib.routing.schemas.ab_routing import ABLeg, ABRoute
-from goatlib.routing.schemas.base import Location, Mode
+from goatlib.routing.schemas.base import Coordinates, Mode
 
 logger = logging.getLogger(__name__)
 
@@ -29,26 +29,26 @@ class RouteValidator:
     def __init__(self) -> None:
         # Speed limits in km/h for different modes
         self.max_speeds = {
-            Mode.WALK: 8.0,  # Fast walking
-            Mode.BIKE: 35.0,  # E-bike or very fast cycling
-            Mode.CAR: 120.0,  # Highway speeds
-            Mode.BUS: 80.0,  # Urban bus max speed
-            Mode.TRAM: 60.0,  # Urban tram max speed
-            Mode.RAIL: 200.0,  # High-speed rail
-            Mode.SUBWAY: 80.0,  # Metro max speed
-            Mode.TRANSIT: 200.0,  # Generic transit (conservative)
+            Mode.walk: 8.0,  # Fast walking
+            Mode.bicycle: 35.0,  # E-bike or very fast cycling
+            Mode.car: 120.0,  # Highway speeds
+            Mode.bus: 80.0,  # Urban bus max speed
+            Mode.tram: 60.0,  # Urban tram max speed
+            Mode.rail: 200.0,  # High-speed rail
+            Mode.subway: 80.0,  # Metro max speed
+            Mode.transit: 200.0,  # Generic transit (conservative)
         }
 
         # Minimum speeds in km/h (below which is suspicious)
         self.min_speeds = {
-            Mode.WALK: 1.0,  # Very slow walking
-            Mode.BIKE: 5.0,  # Very slow cycling
-            Mode.CAR: 10.0,  # Traffic jam speeds
-            Mode.BUS: 5.0,  # Heavy traffic
-            Mode.TRAM: 5.0,  # Heavy traffic
-            Mode.RAIL: 20.0,  # Stopping train
-            Mode.SUBWAY: 10.0,  # Stopping metro
-            Mode.TRANSIT: 5.0,  # Conservative minimum
+            Mode.walk: 1.0,  # Very slow walking
+            Mode.bicycle: 5.0,  # Very slow cycling
+            Mode.car: 10.0,  # Traffic jam speeds
+            Mode.bus: 5.0,  # Heavy traffic
+            Mode.tram: 5.0,  # Heavy traffic
+            Mode.rail: 20.0,  # Stopping train
+            Mode.subway: 10.0,  # Stopping metro
+            Mode.transit: 5.0,  # Conservative minimum
         }
 
         # Transfer time limits
@@ -137,7 +137,7 @@ def _validate_route_connectivity(self, route: ABRoute) -> List[PlausibilityIssue
             current_leg = route.legs[i]
             next_leg = route.legs[i + 1]
 
-            # Check location connectivity
+            # Check Coordinates connectivity
             distance = self._calculate_distance(
                 current_leg.destination, next_leg.origin
             )
@@ -169,7 +169,7 @@ def _validate_route_connectivity(self, route: ABRoute) -> List[PlausibilityIssue
             elif -max_acceptable_overlap <= time_gap < 0:
                 # Small overlap is acceptable, especially for walking to transit
                 if not (
-                    current_leg.mode == Mode.WALK
+                    current_leg.mode == Mode.walk
                     and self._is_transit_mode(next_leg.mode)
                 ):
                     issues.append(
@@ -201,7 +201,7 @@ def _validate_walking_distance(self, route: ABRoute) -> List[PlausibilityIssue]:
         total_walking = sum(
             leg.distance or 0
             for leg in route.legs
-            if leg.mode == Mode.WALK and leg.distance
+            if leg.mode == Mode.walk and leg.distance
         )
 
         if total_walking > self.max_walking_distance:
@@ -265,7 +265,7 @@ def _validate_leg(self, leg: ABLeg, index: int) -> List[PlausibilityIssue]:
                 )
 
             # For walking legs, we can still do some basic validation since MOTIS provides actual distance
-            if leg.mode == Mode.WALK:
+            if leg.mode == Mode.walk:
                 straight_line = self._calculate_distance(leg.origin, leg.destination)
                 if straight_line > 0:
                     ratio = leg.distance / straight_line
@@ -342,7 +342,7 @@ def _validate_transfers(self, route: ABRoute) -> List[PlausibilityIssue]:
 
     def _is_transit_mode(self, mode: Mode) -> bool:
         """Check if mode is public transit."""
-        return mode in [Mode.TRANSIT, Mode.BUS, Mode.TRAM, Mode.RAIL, Mode.SUBWAY]
+        return mode in [Mode.transit, Mode.bus, Mode.tram, Mode.rail, Mode.subway]
 
     def _calculate_speed_kmh(self, leg: ABLeg) -> float:
         """Calculate average speed in km/h for a leg."""
@@ -350,8 +350,8 @@ def _calculate_speed_kmh(self, leg: ABLeg) -> float:
             return 0.0
         return (leg.distance / 1000) / (leg.duration / 3600)
 
-    def _calculate_distance(self, loc1: Location, loc2: Location) -> float:
-        """Calculate distance between two locations in meters (Haversine)."""
+    def _calculate_distance(self, loc1: Coordinates, loc2: Coordinates) -> float:
+        """Calculate distance between two Coordinatess in meters (Haversine)."""
         import math
 
         # Convert to radians
diff --git a/packages/python/goatlib/tests/integration/routing/conftest.py b/packages/python/goatlib/tests/integration/routing/conftest.py
index 8f44e50d3..96111b55d 100644
--- a/packages/python/goatlib/tests/integration/routing/conftest.py
+++ b/packages/python/goatlib/tests/integration/routing/conftest.py
@@ -2,12 +2,11 @@
 
 import pytest_asyncio
 from goatlib.routing.adapters.motis import MotisPlanApiAdapter, create_motis_adapter
+from goatlib.routing.schemas.base import AccessEgressMode, CatchmentAreaRoutingModePT
 from goatlib.routing.schemas.catchment_area_transit import (
-    AccessEgressMode,
-    CatchmentAreaRoutingModePT,
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaStartingPoints,
-    TransitCatchmentAreaTravelTimeCost,
+    TravelTimeCost,
 )
 
 
@@ -47,11 +46,12 @@ async def motis_adapter_fixture(
 @pytest_asyncio.fixture
 def berlin_request() -> TransitCatchmentAreaRequest:
     """Create a standard Berlin transit catchment area request."""
+    starting_points = TransitCatchmentAreaStartingPoints(
+        lat=[52.5200],
+        lon=[13.4050],  # Berlin center
+    )
     return TransitCatchmentAreaRequest(
-        starting_points=TransitCatchmentAreaStartingPoints(
-            latitude=[52.5200],  # Berlin center
-            longitude=[13.4050],
-        ),
+        starting_points=starting_points,
         transit_modes=[
             CatchmentAreaRoutingModePT.bus,
             CatchmentAreaRoutingModePT.tram,
@@ -59,7 +59,7 @@ def berlin_request() -> TransitCatchmentAreaRequest:
         ],
         access_mode=AccessEgressMode.walk,
         egress_mode=AccessEgressMode.walk,
-        travel_cost=TransitCatchmentAreaTravelTimeCost(
+        travel_cost=TravelTimeCost(
             max_traveltime=30,
             cutoffs=[15, 30],  # 15 and 30 minute isochrones
         ),
@@ -69,11 +69,12 @@ def berlin_request() -> TransitCatchmentAreaRequest:
 @pytest_asyncio.fixture
 def munich_request() -> TransitCatchmentAreaRequest:
     """Create a Munich transit catchment area request for testing."""
+    starting_points = TransitCatchmentAreaStartingPoints(
+        lat=[48.1351],
+        lon=[11.5820],  # Munich center
+    )
     return TransitCatchmentAreaRequest(
-        starting_points=TransitCatchmentAreaStartingPoints(
-            latitude=[48.1351],  # Munich center
-            longitude=[11.5820],
-        ),
+        starting_points=starting_points,
         transit_modes=[
             CatchmentAreaRoutingModePT.rail,
             CatchmentAreaRoutingModePT.subway,
@@ -81,7 +82,7 @@ def munich_request() -> TransitCatchmentAreaRequest:
         ],
         access_mode=AccessEgressMode.walk,
         egress_mode=AccessEgressMode.walk,
-        travel_cost=TransitCatchmentAreaTravelTimeCost(
+        travel_cost=TravelTimeCost(
             max_traveltime=45,
             cutoffs=[15, 30, 45],  # Three isochrone bands
         ),
@@ -91,13 +92,14 @@ def munich_request() -> TransitCatchmentAreaRequest:
 @pytest_asyncio.fixture
 def simple_berlin_request() -> TransitCatchmentAreaRequest:
     """Create a simple Berlin request for minimal testing."""
+    starting_points = TransitCatchmentAreaStartingPoints(
+        lat=[52.5200],
+        lon=[13.4050],  # Berlin
+    )
     return TransitCatchmentAreaRequest(
-        starting_points=TransitCatchmentAreaStartingPoints(
-            latitude=[52.5200],  # Berlin
-            longitude=[13.4050],
-        ),
+        starting_points=starting_points,
         transit_modes=[CatchmentAreaRoutingModePT.subway],
         access_mode=AccessEgressMode.walk,
         egress_mode=AccessEgressMode.walk,
-        travel_cost=TransitCatchmentAreaTravelTimeCost(max_traveltime=15, cutoffs=[15]),
+        travel_cost=TravelTimeCost(max_traveltime=15, cutoffs=[15]),
     )
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_edge_cases.py b/packages/python/goatlib/tests/integration/routing/test_motis_adapter_edge_cases.py
index f18874c37..425c31801 100644
--- a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_edge_cases.py
+++ b/packages/python/goatlib/tests/integration/routing/test_motis_adapter_edge_cases.py
@@ -1,6 +1,6 @@
 from goatlib.routing.adapters.motis import MotisPlanApiAdapter
 from goatlib.routing.schemas.ab_routing import ABRoutingRequest
-from goatlib.routing.schemas.base import Location, Mode
+from goatlib.routing.schemas.base import Coordinates, Mode
 
 
 async def test_very_short_distance_routing(
@@ -8,9 +8,9 @@ async def test_very_short_distance_routing(
 ) -> None:
     """Test routing for very short distances."""
     request = ABRoutingRequest(
-        origin=Location(lat=52.5200, lon=13.4050),
-        destination=Location(lat=52.5201, lon=13.4051),
-        modes=[Mode.WALK],
+        origin=Coordinates(lat=52.5200, lon=13.4050),
+        destination=Coordinates(lat=52.5201, lon=13.4051),
+        modes=[Mode.walk],
         max_results=1,
     )
 
@@ -27,9 +27,11 @@ async def test_single_transport_mode_edge_case(
 ) -> None:
     """Test routing with single transport mode at edge case coordinates."""
     request = ABRoutingRequest(
-        origin=Location(lat=52.5200, lon=13.4050),
-        destination=Location(lat=52.5200001, lon=13.4050001),  # Very close coordinates
-        modes=[Mode.WALK],  # Only walking for micro-distance
+        origin=Coordinates(lat=52.5200, lon=13.4050),
+        destination=Coordinates(
+            lat=52.5200001, lon=13.4050001
+        ),  # Very close coordinates
+        modes=[Mode.walk],  # Only walking for micro-distance
         max_results=1,
     )
 
@@ -39,7 +41,7 @@ async def test_single_transport_mode_edge_case(
     if len(routes) > 0:
         # For very short distances, should primarily return walking
         walk_legs_found = any(
-            leg.mode == Mode.WALK for route in routes for leg in route.legs
+            leg.mode == Mode.walk for route in routes for leg in route.legs
         )
         assert walk_legs_found, "Should have walking legs for micro-distances"
 
@@ -49,9 +51,9 @@ async def test_extreme_coordinates_boundaries(
 ) -> None:
     """Test with coordinates at extreme but valid boundaries."""
     request = ABRoutingRequest(
-        origin=Location(lat=85.0, lon=179.0),  # Near north pole and dateline
-        destination=Location(lat=84.9, lon=178.9),  # Slightly different
-        modes=[Mode.WALK],
+        origin=Coordinates(lat=85.0, lon=179.0),  # Near north pole and dateline
+        destination=Coordinates(lat=84.9, lon=178.9),  # Slightly different
+        modes=[Mode.walk],
         max_results=1,
     )
 
@@ -66,9 +68,9 @@ async def test_duplicate_transport_modes_handling(
 ) -> None:
     """Test handling of duplicate transport modes."""
     request = ABRoutingRequest(
-        origin=Location(lat=52.5200, lon=13.4050),
-        destination=Location(lat=53.5511, lon=9.9937),
-        modes=[Mode.TRANSIT, Mode.TRANSIT],  # Duplicates
+        origin=Coordinates(lat=52.5200, lon=13.4050),
+        destination=Coordinates(lat=53.5511, lon=9.9937),
+        modes=[Mode.transit, Mode.transit],  # Duplicates
         max_results=1,
     )
 
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_errors.py b/packages/python/goatlib/tests/integration/routing/test_motis_adapter_errors.py
index 1216dc75a..4674decfa 100644
--- a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_errors.py
+++ b/packages/python/goatlib/tests/integration/routing/test_motis_adapter_errors.py
@@ -4,7 +4,7 @@
 from goatlib.routing.adapters.motis import MotisPlanApiAdapter, create_motis_adapter
 from goatlib.routing.errors import RoutingError
 from goatlib.routing.schemas.ab_routing import ABRoutingRequest
-from goatlib.routing.schemas.base import Location, Mode
+from goatlib.routing.schemas.base import Coordinates, Mode
 
 
 async def test_invalid_api_url_handling() -> None:
@@ -15,9 +15,9 @@ async def test_invalid_api_url_handling() -> None:
     )
 
     request = ABRoutingRequest(
-        origin=Location(lat=52.5200, lon=13.4050),
-        destination=Location(lat=53.5511, lon=9.9937),
-        modes=[Mode.TRANSIT],
+        origin=Coordinates(lat=52.5200, lon=13.4050),
+        destination=Coordinates(lat=53.5511, lon=9.9937),
+        modes=[Mode.transit],
         max_results=1,
     )
 
@@ -35,9 +35,9 @@ async def test_api_timeout_handling(motis_adapter_online: MotisPlanApiAdapter) -
         mock_get.side_effect = Exception("Connection timeout")
 
         request = ABRoutingRequest(
-            origin=Location(lat=52.5, lon=13.4),
-            destination=Location(lat=53.5, lon=9.9),
-            modes=[Mode.TRANSIT],
+            origin=Coordinates(lat=52.5, lon=13.4),
+            destination=Coordinates(lat=53.5, lon=9.9),
+            modes=[Mode.transit],
             max_results=1,
         )
 
@@ -58,9 +58,9 @@ async def test_malformed_api_response_handling(
         mock_get.return_value = mock_response
 
         request = ABRoutingRequest(
-            origin=Location(lat=52.5, lon=13.4),
-            destination=Location(lat=53.5, lon=9.9),
-            modes=[Mode.TRANSIT],
+            origin=Coordinates(lat=52.5, lon=13.4),
+            destination=Coordinates(lat=53.5, lon=9.9),
+            modes=[Mode.transit],
             max_results=1,
         )
 
@@ -82,9 +82,9 @@ async def test_http_error_status_handling(
         mock_get.return_value = mock_response
 
         request = ABRoutingRequest(
-            origin=Location(lat=52.5, lon=13.4),
-            destination=Location(lat=53.5, lon=9.9),
-            modes=[Mode.TRANSIT],
+            origin=Coordinates(lat=52.5, lon=13.4),
+            destination=Coordinates(lat=53.5, lon=9.9),
+            modes=[Mode.transit],
             max_results=1,
         )
 
@@ -108,9 +108,9 @@ def raise_json_error() -> None:
         mock_get.return_value = mock_response
 
         request = ABRoutingRequest(
-            origin=Location(lat=52.5, lon=13.4),
-            destination=Location(lat=53.5, lon=9.9),
-            modes=[Mode.TRANSIT],
+            origin=Coordinates(lat=52.5, lon=13.4),
+            destination=Coordinates(lat=53.5, lon=9.9),
+            modes=[Mode.transit],
             max_results=1,
         )
 
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_fixture.py b/packages/python/goatlib/tests/integration/routing/test_motis_adapter_fixture.py
index b2b9e36d3..f425a7f82 100644
--- a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_fixture.py
+++ b/packages/python/goatlib/tests/integration/routing/test_motis_adapter_fixture.py
@@ -2,12 +2,7 @@
 from goatlib.routing.adapters.motis import MotisPlanApiAdapter, create_motis_adapter
 from goatlib.routing.errors import RoutingError
 from goatlib.routing.schemas.ab_routing import ABRoute, ABRoutingRequest
-from goatlib.routing.schemas.base import (
-    DEFAULT_MAX_SPEED_KMH,
-    MAX_SPEEDS_KMH,
-    Location,
-    Mode,
-)
+from goatlib.routing.schemas.base import Coordinates, Mode
 
 
 # --- Helper Functions ---
@@ -39,9 +34,9 @@ def validate_route_data(routes: list[ABRoute]) -> None:
 def test_request() -> ABRoutingRequest:
     """Standard, module-scoped test request for fixture testing."""
     return ABRoutingRequest(
-        origin=Location(lat=48.1351, lon=11.5820),  # Munich
-        destination=Location(lat=48.7758, lon=9.1829),  # Stuttgart
-        modes=[Mode.TRANSIT, Mode.WALK],
+        origin=Coordinates(lat=48.1351, lon=11.5820),  # Munich
+        destination=Coordinates(lat=48.7758, lon=9.1829),  # Stuttgart
+        modes=[Mode.transit, Mode.walk],
         max_results=3,
     )
 
@@ -87,15 +82,12 @@ async def test_fixture_route_realism_validation(
         ), f"Route duration {route.duration}s is unrealistic"
 
         for leg in route.legs:
-            if leg.mode == Mode.WALK:
-                continue
-
             # Speed checks are only meaningful if both duration and distance are available
-            if leg.duration > 0 and leg.distance is not None:
+            if leg.duration > 0 and leg.distance is not None and leg.distance > 0:
                 speed_kmh = (leg.distance / 1000) / (leg.duration / 3600)
-                max_speed = MAX_SPEEDS_KMH.get(leg.mode, DEFAULT_MAX_SPEED_KMH)
+                # Basic sanity check: speed should be between 1 and 300 km/h
                 assert (
-                    5 <= speed_kmh <= max_speed
+                    1 <= speed_kmh <= 300
                 ), f"Leg {leg.leg_id} ({leg.mode.value}) has unrealistic speed: {speed_kmh:.1f} km/h."
             # For transit legs without distance data (common with MOTIS), we can't validate speed
             # This is expected behavior since MOTIS doesn't always provide route distances for transit
@@ -111,9 +103,9 @@ async def test_empty_fixture_directory(tmp_path: pytest.TempPathFactory) -> None
 
     adapter = create_motis_adapter(use_fixtures=True, fixture_path=empty_dir)
     request = ABRoutingRequest(
-        origin=Location(lat=48.1, lon=11.5),
-        destination=Location(lat=48.2, lon=11.6),
-        modes=[Mode.WALK],
+        origin=Coordinates(lat=48.1, lon=11.5),
+        destination=Coordinates(lat=48.2, lon=11.6),
+        modes=[Mode.walk],
         max_results=1,
     )
 
@@ -136,9 +128,9 @@ async def test_corrupted_fixture_file_handling(
 
     adapter = create_motis_adapter(use_fixtures=True, fixture_path=tmp_path)
     request = ABRoutingRequest(
-        origin=Location(lat=48.1, lon=11.5),
-        destination=Location(lat=48.2, lon=11.6),
-        modes=[Mode.WALK],
+        origin=Coordinates(lat=48.1, lon=11.5),
+        destination=Coordinates(lat=48.2, lon=11.6),
+        modes=[Mode.walk],
         max_results=1,
     )
 
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_one_to_all.py b/packages/python/goatlib/tests/integration/routing/test_motis_adapter_one_to_all.py
index 00beba082..10d06a5a7 100644
--- a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_one_to_all.py
+++ b/packages/python/goatlib/tests/integration/routing/test_motis_adapter_one_to_all.py
@@ -1,77 +1,15 @@
 import pytest
-from goatlib.routing.schemas.catchment_area_transit import (
+from goatlib.routing.schemas.base import (
     AccessEgressMode,
     CatchmentAreaRoutingModePT,
+)
+from goatlib.routing.schemas.catchment_area_transit import (
     TransitCatchmentAreaRequest,
-    TransitCatchmentAreaResponse,
     TransitCatchmentAreaStartingPoints,
-    TransitCatchmentAreaTravelTimeCost,
+    TravelTimeCost,
 )
 
 
-def validate_response_structure(
-    response: TransitCatchmentAreaResponse, expected_cutoffs: list[int]
-) -> None:
-    """
-    Validate the basic structure and consistency of a transit catchment area response.
-
-    Args:
-        response: The response to validate
-        expected_cutoffs: List of expected cutoff times
-    """
-    # Validate response structure
-    assert response is not None
-    assert hasattr(response, "polygons")
-    assert hasattr(response, "metadata")
-
-    # Validate metadata structure
-    assert response.metadata is not None
-    total_locations = response.metadata.get("total_locations", 0)
-    assert total_locations >= 0
-
-    # If no reachable locations, polygons list should be empty
-    if total_locations == 0:
-        assert len(response.polygons) == 0
-        return
-
-    # Should generate polygons for each cutoff when locations are reachable
-    assert len(response.polygons) == len(expected_cutoffs)
-
-    # Validate each polygon
-    for polygon in response.polygons:
-        assert polygon.travel_time in expected_cutoffs
-        assert polygon.geometry is not None
-        assert polygon.geometry["type"] == "Polygon"
-        assert "coordinates" in polygon.geometry
-
-    # Additional metadata validation for successful responses
-    assert response.metadata.get("source") == "motis_one_to_all"
-
-    # Check that travel times match cutoffs and are properly ordered
-    travel_times = [p.travel_time for p in response.polygons]
-    assert sorted(travel_times) == sorted(expected_cutoffs)
-
-
-def validate_polygon_geometry(response: TransitCatchmentAreaResponse) -> None:
-    """Validate that polygon geometries have correct GeoJSON structure."""
-    for polygon in response.polygons:
-        geometry = polygon.geometry
-
-        # Check GeoJSON Polygon structure
-        assert geometry["type"] == "Polygon"
-        assert "coordinates" in geometry
-        assert isinstance(geometry["coordinates"], list)
-
-        # Check that coordinates form a valid polygon
-        if geometry["coordinates"]:
-            coord_ring = geometry["coordinates"][0]
-            assert len(coord_ring) >= 4  # Minimum for a closed polygon
-            assert len(coord_ring[0]) == 2  # [lon, lat] format
-
-            # First and last coordinates should be the same (closed polygon)
-            assert coord_ring[0] == coord_ring[-1]
-
-
 @pytest.mark.slow
 @pytest.mark.network
 class TestMotisAdapterOneToAll:
@@ -81,108 +19,120 @@ async def test_basic_one_to_all_success(self, motis_adapter_online, berlin_reque
         """Test basic one-to-all functionality returns valid catchment areas."""
         response = await motis_adapter_online.get_transit_catchment_area(berlin_request)
 
-        validate_response_structure(response, berlin_request.travel_cost.cutoffs)
-        validate_polygon_geometry(response)
+        # Basic structure checks
+        assert response is not None
+        assert len(response.polygons) == len(berlin_request.travel_cost.cutoffs)
+        assert response.metadata.get("total_locations", 0) > 0
+        assert response.metadata.get("source") == "motis_one_to_all"
 
-        # Berlin should have reachable locations
-        assert response.metadata["total_locations"] > 0
+        # Check each polygon
+        for polygon in response.polygons:
+            assert polygon.travel_time in berlin_request.travel_cost.cutoffs
+            assert polygon.geometry["type"] == "Polygon"
+            assert "coordinates" in polygon.geometry
 
     async def test_multiple_cutoffs(self, motis_adapter_online, munich_request):
         """Test that multiple travel time cutoffs generate correct polygons."""
         response = await motis_adapter_online.get_transit_catchment_area(munich_request)
 
-        validate_response_structure(response, munich_request.travel_cost.cutoffs)
+        assert len(response.polygons) == len(munich_request.travel_cost.cutoffs)
 
         # Polygons should be ordered by travel time
-        for i, polygon in enumerate(response.polygons):
-            assert polygon.travel_time == sorted(munich_request.travel_cost.cutoffs)[i]
+        travel_times = [p.travel_time for p in response.polygons]
+        assert sorted(travel_times) == sorted(munich_request.travel_cost.cutoffs)
 
     async def test_different_transit_modes(self, motis_adapter_online):
         """Test different combinations of transit modes."""
+        starting_points = TransitCatchmentAreaStartingPoints(
+            lat=[52.5200], lon=[13.4050]
+        )
         rail_only_request = TransitCatchmentAreaRequest(
-            starting_points=TransitCatchmentAreaStartingPoints(
-                latitude=[52.5200], longitude=[13.4050]
-            ),
+            starting_points=starting_points,
             transit_modes=[CatchmentAreaRoutingModePT.rail],
             access_mode=AccessEgressMode.walk,
             egress_mode=AccessEgressMode.walk,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
-                max_traveltime=20, cutoffs=[20]
-            ),
+            travel_cost=TravelTimeCost(max_traveltime=20, cutoffs=[20]),
         )
 
         response = await motis_adapter_online.get_transit_catchment_area(
             rail_only_request
         )
 
-        validate_response_structure(response, [20])
+        assert len(response.polygons) == 1
+        assert response.polygons[0].travel_time == 20
 
     async def test_single_cutoff(self, motis_adapter_online):
         """Test with a single travel time cutoff."""
+        starting_points = TransitCatchmentAreaStartingPoints(
+            lat=[48.1351],
+            lon=[11.5820],  # Munich
+        )
         single_cutoff_request = TransitCatchmentAreaRequest(
-            starting_points=TransitCatchmentAreaStartingPoints(
-                latitude=[48.1351],  # Munich
-                longitude=[11.5820],
-            ),
+            starting_points=starting_points,
             transit_modes=[
                 CatchmentAreaRoutingModePT.subway,
                 CatchmentAreaRoutingModePT.tram,
             ],
             access_mode=AccessEgressMode.walk,
             egress_mode=AccessEgressMode.walk,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
-                max_traveltime=20, cutoffs=[20]
-            ),
+            travel_cost=TravelTimeCost(max_traveltime=20, cutoffs=[20]),
         )
 
         response = await motis_adapter_online.get_transit_catchment_area(
             single_cutoff_request
         )
 
-        validate_response_structure(response, [20])
+        assert len(response.polygons) == 1
+        assert response.polygons[0].travel_time == 20
 
     async def test_geometry_structure(self, motis_adapter_online, berlin_request):
         """Test that returned geometry has correct GeoJSON structure."""
         response = await motis_adapter_online.get_transit_catchment_area(berlin_request)
 
-        validate_polygon_geometry(response)
+        for polygon in response.polygons:
+            assert polygon.geometry["type"] == "Polygon"
+            assert "coordinates" in polygon.geometry
+            if polygon.geometry["coordinates"]:
+                coord_ring = polygon.geometry["coordinates"][0]
+                assert len(coord_ring) >= 4
+                assert len(coord_ring[0]) == 2
+                assert coord_ring[0] == coord_ring[-1]
 
     @pytest.mark.skip(reason="MOTIS bicycle access causes 500 error on public instance")
     async def test_bike_access_egress(self, motis_adapter_online):
         """Test catchment area with bicycle access and egress modes."""
+        starting_points = TransitCatchmentAreaStartingPoints(
+            lat=[52.5200], lon=[13.4050]
+        )
         bike_request = TransitCatchmentAreaRequest(
-            starting_points=TransitCatchmentAreaStartingPoints(
-                latitude=[52.5200], longitude=[13.4050]
-            ),
+            starting_points=starting_points,
             transit_modes=[
                 CatchmentAreaRoutingModePT.bus,
                 CatchmentAreaRoutingModePT.tram,
             ],
             access_mode=AccessEgressMode.bicycle,
             egress_mode=AccessEgressMode.bicycle,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
-                max_traveltime=25, cutoffs=[25]
-            ),
+            travel_cost=TravelTimeCost(max_traveltime=25, cutoffs=[25]),
         )
 
         response = await motis_adapter_online.get_transit_catchment_area(bike_request)
 
-        validate_response_structure(response, [25])
+        assert len(response.polygons) == 1
+        assert response.polygons[0].travel_time == 25
 
     async def test_invalid_coordinates_handling(self, motis_adapter_online):
         """Test handling of coordinates outside valid geographic range."""
         # MOTIS accepts invalid coordinates and returns empty results
+        starting_points = TransitCatchmentAreaStartingPoints(
+            lat=[91.0],
+            lon=[181.0],  # Invalid coordinates
+        )
         invalid_request = TransitCatchmentAreaRequest(
-            starting_points=TransitCatchmentAreaStartingPoints(
-                latitude=[91.0],  # Invalid latitude > 90
-                longitude=[181.0],  # Invalid longitude > 180
-            ),
+            starting_points=starting_points,
             transit_modes=[CatchmentAreaRoutingModePT.bus],
             access_mode=AccessEgressMode.walk,
             egress_mode=AccessEgressMode.walk,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
-                max_traveltime=15, cutoffs=[15]
-            ),
+            travel_cost=TravelTimeCost(max_traveltime=15, cutoffs=[15]),
         )
 
         response = await motis_adapter_online.get_transit_catchment_area(
@@ -190,9 +140,8 @@ async def test_invalid_coordinates_handling(self, motis_adapter_online):
         )
 
         # Should return valid structure but with no locations
-        validate_response_structure(response, [15])
-        # Specifically check that no locations were found
         assert response.metadata.get("total_locations", 0) == 0
+        assert len(response.polygons) == 0
 
 
 @pytest.mark.slow
@@ -207,7 +156,8 @@ async def test_motis_one_to_all_integration_minimal(
 
     try:
         response = await adapter.get_transit_catchment_area(simple_berlin_request)
-        validate_response_structure(response, simple_berlin_request.travel_cost.cutoffs)
+        assert len(response.polygons) == len(simple_berlin_request.travel_cost.cutoffs)
+        assert response.metadata.get("source") == "motis_one_to_all"
 
     finally:
         await adapter.motis_client.close()
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_online.py b/packages/python/goatlib/tests/integration/routing/test_motis_adapter_online.py
index 86aab7715..d1e9e7506 100644
--- a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_online.py
+++ b/packages/python/goatlib/tests/integration/routing/test_motis_adapter_online.py
@@ -2,12 +2,7 @@
 import pytest_asyncio
 from goatlib.routing.adapters.motis import MotisPlanApiAdapter
 from goatlib.routing.schemas.ab_routing import ABRoute, ABRoutingRequest
-from goatlib.routing.schemas.base import (
-    DEFAULT_MAX_SPEED_KMH,
-    MAX_SPEEDS_KMH,
-    Location,
-    Mode,
-)
+from goatlib.routing.schemas.base import Coordinates, Mode
 
 
 # --- Helper Functions ---
@@ -35,9 +30,9 @@ def validate_route_data(routes: list[ABRoute]) -> None:
 def test_request() -> ABRoutingRequest:
     """Standard, module-scoped test request for fixture testing."""
     return ABRoutingRequest(
-        origin=Location(lat=48.1351, lon=11.5820),  # Munich
-        destination=Location(lat=48.7758, lon=9.1829),  # Stuttgart
-        modes=[Mode.TRANSIT, Mode.WALK],
+        origin=Coordinates(lat=48.1351, lon=11.5820),  # Munich
+        destination=Coordinates(lat=48.7758, lon=9.1829),  # Stuttgart
+        modes=[Mode.transit, Mode.walk],
         max_results=3,
     )
 
@@ -65,15 +60,15 @@ async def test_fixture_different_requests_return_data(
 ) -> None:
     """Test that different requests can successfully load different fixture files."""
     request1 = ABRoutingRequest(
-        origin=Location(lat=48.1351, lon=11.5820),  # Munich
-        destination=Location(lat=48.7758, lon=9.1829),  # Stuttgart
-        modes=[Mode.TRANSIT, Mode.WALK],
+        origin=Coordinates(lat=48.1351, lon=11.5820),  # Munich
+        destination=Coordinates(lat=48.7758, lon=9.1829),  # Stuttgart
+        modes=[Mode.transit, Mode.walk],
         max_results=3,
     )
     request2 = ABRoutingRequest(
-        origin=Location(lat=52.5200, lon=13.4050),  # Berlin
-        destination=Location(lat=53.5511, lon=9.9937),  # Hamburg
-        modes=[Mode.TRANSIT, Mode.WALK],
+        origin=Coordinates(lat=52.5200, lon=13.4050),  # Berlin
+        destination=Coordinates(lat=53.5511, lon=9.9937),  # Hamburg
+        modes=[Mode.transit, Mode.walk],
         max_results=3,
     )
 
@@ -91,9 +86,9 @@ async def test_fixture_max_results_enforcement(
 ) -> None:
     """Test that max_results parameter is respected by the client-side logic."""
     request = ABRoutingRequest(
-        origin=Location(lat=48.1351, lon=11.5820),
-        destination=Location(lat=48.7758, lon=9.1829),
-        modes=[Mode.TRANSIT],
+        origin=Coordinates(lat=48.1351, lon=11.5820),
+        destination=Coordinates(lat=48.7758, lon=9.1829),
+        modes=[Mode.transit],
         max_results=5,  # Request fewer than the default
     )
 
@@ -124,7 +119,7 @@ async def test_fixture_distance_calculation_and_speed_realism(
         ), f"Route duration {route.duration}s is unrealistic"
 
         for leg in route.legs:
-            if leg.mode == Mode.WALK:
+            if leg.mode == Mode.walk:
                 continue  # Speed checks aren't as relevant for walking
 
             assert (
@@ -137,8 +132,8 @@ async def test_fixture_distance_calculation_and_speed_realism(
             # Avoid division by zero if duration is somehow 0
             if leg.duration > 0:
                 speed_kmh = (leg.distance / 1000) / (leg.duration / 3600)
-                max_speed = MAX_SPEEDS_KMH.get(leg.mode, DEFAULT_MAX_SPEED_KMH)
-                assert 5 <= speed_kmh <= max_speed, (
+                # Basic sanity check: speed should be between 1 and 300 km/h
+                assert 1 <= speed_kmh <= 300, (
                     f"Leg {leg.leg_id} ({leg.mode.value}) has unrealistic speed: {speed_kmh:.1f} km/h. "
-                    f"Expected 5-{max_speed} km/h."
+                    f"Expected 1-300 km/h."
                 )
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_bus_station_buffers.py b/packages/python/goatlib/tests/integration/routing/test_motis_bus_station_buffers.py
index 600a0fb63..2bdcfdd93 100644
--- a/packages/python/goatlib/tests/integration/routing/test_motis_bus_station_buffers.py
+++ b/packages/python/goatlib/tests/integration/routing/test_motis_bus_station_buffers.py
@@ -13,11 +13,11 @@
     extract_bus_stations_for_buffering,
     translate_to_motis_one_to_all_request,
 )
+from goatlib.routing.schemas.base import CatchmentAreaRoutingModePT
 from goatlib.routing.schemas.catchment_area_transit import (
-    CatchmentAreaRoutingModePT,
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaStartingPoints,
-    TransitCatchmentAreaTravelTimeCost,
+    TravelTimeCost,
 )
 from shapely.geometry import Point
 
@@ -81,18 +81,19 @@ def create_pt_buffer_params(
 @pytest.fixture
 def sample_request() -> TransitCatchmentAreaRequest:
     """Munich City Center Request."""
+    starting_points = TransitCatchmentAreaStartingPoints(
+        lat=[48.1351],
+        lon=[11.582],  # Munich center
+    )
     return TransitCatchmentAreaRequest(
-        starting_points=TransitCatchmentAreaStartingPoints(
-            latitude=[48.1351],
-            longitude=[11.582],  # Munich center
-        ),
+        starting_points=starting_points,
         transit_modes=[
             CatchmentAreaRoutingModePT.bus,
             CatchmentAreaRoutingModePT.subway,
             CatchmentAreaRoutingModePT.tram,
             CatchmentAreaRoutingModePT.rail,
         ],
-        travel_cost=TransitCatchmentAreaTravelTimeCost(max_traveltime=60, cutoffs=[60]),
+        travel_cost=TravelTimeCost(max_traveltime=60, cutoffs=[60]),
     )
 
 
diff --git a/packages/python/goatlib/tests/unit/routing/test_ab_routing_schemas.py b/packages/python/goatlib/tests/unit/routing/test_ab_routing_schemas.py
index d2fbb2984..8360a1f85 100644
--- a/packages/python/goatlib/tests/unit/routing/test_ab_routing_schemas.py
+++ b/packages/python/goatlib/tests/unit/routing/test_ab_routing_schemas.py
@@ -8,7 +8,7 @@
     ABRoutingRequest,
     ABRoutingResponse,
 )
-from goatlib.routing.schemas.base import Location, Mode
+from goatlib.routing.schemas.base import Coordinates, Mode
 from pydantic import ValidationError
 
 # =====================================================================
@@ -17,20 +17,20 @@
 
 
 @pytest.fixture
-def valid_location_data() -> Dict[str, float]:
-    """Provides valid data for a Location model."""
-    return {"lat": 48.8566, "lon": 2.3522}
+def valid_coordinates_data() -> Coordinates:
+    """Provides valid data for a Coordinates model."""
+    return Coordinates(lat=48.8566, lon=2.3522)  # Munich coordinates
 
 
 @pytest.fixture
-def valid_leg_data(valid_location_data: Dict[str, float]) -> Dict[str, Any]:
+def valid_leg_data(valid_coordinates_data: Coordinates) -> Dict[str, Any]:
     """Provides a valid dictionary for creating an ABLeg."""
     now = datetime.now(timezone.utc)
     return {
         "leg_id": "leg_123",
-        "mode": Mode.WALK,
-        "origin": valid_location_data,
-        "destination": {"lat": 48.8606, "lon": 2.3376},
+        "mode": Mode.walk,
+        "origin": valid_coordinates_data,
+        "destination": Coordinates(lat=48.8606, lon=2.3376),
         "departure_time": now,
         "arrival_time": now + timedelta(seconds=5),
         "duration": 300,
@@ -56,78 +56,64 @@ def valid_route_data(valid_leg_data: Dict[str, Any]) -> Dict[str, Any]:
 
 
 def test_ab_request_creation_with_defaults(
-    valid_location_data: Dict[str, float],
+    valid_coordinates_data: Coordinates,
 ) -> None:
     """Tests that a minimal ABRoutingRequest is created with correct defaults."""
     req = ABRoutingRequest(
-        origin=valid_location_data,
-        destination={"lat": 40.7128, "lon": -74.0060},
-        modes=[Mode.TRANSIT],
+        origin=valid_coordinates_data,
+        destination=Coordinates(lat=40.7128, lon=-74.0060),
+        modes=[Mode.transit],
     )
-
-    assert req.max_results == 5  # Default value
+    assert req.max_results == 5
 
 
 @pytest.mark.parametrize(
     "results, should_fail",
     [
-        (0, True),
-        (11, True),
-        (1, False),
-        (10, False),
-        (5, False),
+        (0, True),  # Lower bound fail (must be >= 1)
+        (11, True),  # Upper bound fail (must be <= 10)
+        (1, False),  # Lower bound success
+        (10, False),  # Upper bound success
+        (5, False),  # Valid middle value
     ],
     ids=["too-low", "too-high", "min-success", "max-success", "valid-middle"],
 )
 def test_ab_request_max_results_constraints(
-    valid_location_data: Dict[str, float], results: int, should_fail: bool
+    valid_coordinates_data: Coordinates, results: int, should_fail: bool
 ) -> None:
     """Tests the ge=1 and le=10 constraints on the max_results field."""
     base_data = {
-        "origin": valid_location_data,
+        "origin": valid_coordinates_data,
         "destination": {"lat": 40.7128, "lon": -74.0060},
-        "modes": [Mode.TRANSIT],
+        "modes": [Mode.transit],
         "max_results": results,
     }
     if should_fail:
-        with pytest.raises(ValidationError):
+        with pytest.raises(ValidationError) as exc_info:
             ABRoutingRequest(**base_data)
+        # Optional: Add an assertion to check the error message
+        if results < 1:
+            assert "Input should be greater than or equal to 1" in str(exc_info.value)
+        else:
+            assert "Input should be less than or equal to 10" in str(exc_info.value)
     else:
         assert ABRoutingRequest(**base_data).max_results == results
 
 
 def test_same_origin_destination_validation() -> None:
     """Test routing validation with identical origin and destination."""
-    location = Location(lat=52.5200, lon=13.4050)
+    coords = Coordinates(lat=52.5200, lon=13.4050)
 
-    # This should raise a validation error since origin == destination
     with pytest.raises(ValidationError) as exc_info:
         ABRoutingRequest(
-            origin=location,
-            destination=location,
-            modes=[Mode.WALK],
-            max_results=1,
+            origin=coords,
+            destination=coords,
+            modes=[Mode.walk],
         )
 
-    # Verify the validation error message
     assert "Origin and destination cannot be the same" in str(exc_info.value)
 
 
-def test_extreme_max_results_validation() -> None:
-    """Test validation with extreme max_results values."""
-    # This should raise a validation error since max_results > 10
-    with pytest.raises(ValidationError) as exc_info:
-        ABRoutingRequest(
-            origin=Location(lat=52.5200, lon=13.4050),
-            destination=Location(lat=53.5511, lon=9.9937),
-            modes=[Mode.TRANSIT],
-            max_results=100,  # Too high - model limits to max 10
-        )
-
-    # Verify the validation error message
-    assert "Input should be less than or equal to 10" in str(exc_info.value)
-
-
 # =====================================================================
 #  SCHEMA TESTS: ABRoute
 # =====================================================================
@@ -155,7 +141,7 @@ def test_ab_route_creation_success(valid_route_data: Dict[str, Any]) -> None:
 )
 def test_ab_route_creation_invalid(duration: float, distance: float) -> None:
     """Tests that a Route with invalid duration or distance raises a ValueError."""
-    with pytest.raises(ValueError):
+    with pytest.raises(ValidationError):
         ABRoute(
             duration=duration,
             distance=distance,
diff --git a/packages/python/goatlib/tests/unit/routing/test_base_schemas.py b/packages/python/goatlib/tests/unit/routing/test_base_schemas.py
index b71f6c434..8e2ac8073 100644
--- a/packages/python/goatlib/tests/unit/routing/test_base_schemas.py
+++ b/packages/python/goatlib/tests/unit/routing/test_base_schemas.py
@@ -2,7 +2,7 @@
 
 import pytest
 from goatlib.routing.schemas.base import (
-    Location,
+    Coordinates,
     Mode,
     Route,
 )
@@ -18,27 +18,27 @@
     ],
     ids=["lat-too-high", "lat-too-low", "lon-too-high", "lon-too-low"],
 )
-def test_location_invalid_coordinates(
+def test_coordinates_invalid_coordinates(
     lat: float, lon: float, expected_error: type
 ) -> None:
     """Test that invalid coordinates raise a ValueError."""
     with pytest.raises(expected_error):
-        Location(lat=lat, lon=lon)
+        Coordinates(lat=lat, lon=lon)
 
 
-def test_location_valid() -> None:
-    """Test creating a valid location."""
-    location = Location(lat=52.5200, lon=13.4050)
-    assert location.lat == 52.5200
-    assert location.lon == 13.4050
+def test_coordinates_valid() -> None:
+    """Test creating a valid Coordinates."""
+    coords = Coordinates(lat=52.5200, lon=13.4050)
+    assert coords.lat == 52.5200
+    assert coords.lon == 13.4050
 
 
 def test_transport_mode_enum() -> None:
     """Test that Mode enum has expected values."""
-    assert Mode.WALK == "walk"
-    assert Mode.BUS == "bus"
-    assert Mode.CAR == "car"
-    assert Mode.TRANSIT == "transit"
+    assert Mode.walk == "walk"
+    assert Mode.bus == "bus"
+    assert Mode.car == "car"
+    assert Mode.transit == "transit"
 
 
 # add a test for route schema
diff --git a/packages/python/goatlib/tests/unit/routing/test_catchment.py b/packages/python/goatlib/tests/unit/routing/test_catchment.py
new file mode 100644
index 000000000..209824e18
--- /dev/null
+++ b/packages/python/goatlib/tests/unit/routing/test_catchment.py
@@ -0,0 +1,224 @@
+import pytest
+from goatlib.routing.schemas.base import CatchmentAreaType
+from goatlib.routing.schemas.catchment import CatchmentSchema
+from pydantic import ValidationError
+
+"""Test cases for CatchmentSchema validation and functionality."""
+
+
+def test_valid_catchment_schema_creation() -> None:
+    """Test creating a valid catchment schema."""
+    data = {
+        "starting_points": [
+            {"lon": 11.123, "lat": 48.1234},
+            {"lon": 11.456, "lat": 48.5678},
+        ],
+        "cutoffs": [10.0, 20.0, 30.0],
+        "type": "polygon",
+    }
+
+    schema = CatchmentSchema(**data)
+    assert len(schema.starting_points) == 2
+    assert schema.starting_points[0].lon == 11.123
+    assert schema.starting_points[0].lat == 48.1234
+    assert schema.starting_points[1].lon == 11.456
+    assert schema.starting_points[1].lat == 48.5678
+    assert schema.cutoffs == [10.0, 20.0, 30.0]
+    assert schema.type == CatchmentAreaType.polygon
+
+
+def test_coordinate_validation_longitude() -> None:
+    """Test longitude coordinate validation."""
+    # Valid longitude range
+    valid_data = {
+        "starting_points": [
+            {"lon": -180.0, "lat": 48.1},
+            {"lon": 0.0, "lat": 48.1},
+            {"lon": 180.0, "lat": 48.1},
+        ],
+        "cutoffs": [10.0],
+        "type": "point",
+    }
+    schema = CatchmentSchema(**valid_data)
+    assert len(schema.starting_points) == 3
+
+    # Invalid longitude - too low
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(
+            starting_points=[{"lon": -180.1, "lat": 48.1}],
+            cutoffs=[10.0],
+            type="point",
+        )
+    assert "greater than or equal to -180" in str(exc_info.value)
+
+    # Invalid longitude - too high
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(
+            starting_points=[{"lon": 180.1, "lat": 48.1}],
+            cutoffs=[10.0],
+            type="point",
+        )
+    assert "less than or equal to 180" in str(exc_info.value)
+
+
+def test_coordinate_validation_latitude() -> None:
+    """Test latitude coordinate validation."""
+    # Valid latitude range
+    valid_data = {
+        "starting_points": [
+            {"lon": 11.0, "lat": -90.0},
+            {"lon": 11.0, "lat": 0.0},
+            {"lon": 11.0, "lat": 90.0},
+        ],
+        "cutoffs": [10.0],
+        "type": "point",
+    }
+    schema = CatchmentSchema(**valid_data)
+    assert len(schema.starting_points) == 3
+
+    # Invalid latitude - too low
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(
+            starting_points=[{"lon": 11.0, "lat": -90.1}],
+            cutoffs=[10.0],
+            type="point",
+        )
+    assert "greater than or equal to -90" in str(exc_info.value)
+
+    # Invalid latitude - too high
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(
+            starting_points=[{"lon": 11.0, "lat": 90.1}],
+            cutoffs=[10.0],
+            type="point",
+        )
+    assert "less than or equal to 90" in str(exc_info.value)
+
+
+def test_invalid_coordinate_count() -> None:
+    """Test validation of coordinate structure."""
+    # Missing required field
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(
+            starting_points=[{"lon": 11.123}],  # Missing lat
+            cutoffs=[10.0],
+            type="point",
+        )
+    assert "Field required" in str(exc_info.value)
+
+    # Invalid format (list instead of dict)
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(
+            starting_points=[[11.123, 48.1234]],  # Should be dict
+            cutoffs=[10.0],
+            type="point",
+        )
+    assert "Input should be a valid dictionary" in str(exc_info.value)
+
+
+def test_empty_starting_points() -> None:
+    """Test validation with empty starting points."""
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(starting_points=[], cutoffs=[10.0], type="point")
+    assert "at least 1" in str(exc_info.value).lower()
+
+
+def test_too_many_starting_points() -> None:
+    """Test validation with many starting points (no hard limit, just verify it works)."""
+    # Create 101 points to verify system can handle many points
+    many_points = [
+        {"lon": 11.0 + i * 0.001, "lat": 48.0 + i * 0.001} for i in range(101)
+    ]
+
+    # Should not raise an error - just verify it works
+    schema = CatchmentSchema(starting_points=many_points, cutoffs=[10.0], type="point")
+    assert len(schema.starting_points) == 101
+
+
+def test_cutoffs_validation() -> None:
+    """Test cutoffs validation."""
+    base_data = {
+        "starting_points": [{"lon": 11.123, "lat": 48.1234}],
+        "type": "point",
+    }
+
+    # Negative cutoff
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(cutoffs=[-5.0], **base_data)
+    assert "must be positive" in str(exc_info.value)
+
+    # Zero cutoff
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(cutoffs=[0.0], **base_data)
+    assert "must be positive" in str(exc_info.value)
+
+    # Unsorted cutoffs should be auto-sorted without error
+    schema = CatchmentSchema(cutoffs=[20.0, 10.0, 30.0], **base_data)
+    assert schema.cutoffs == [10.0, 20.0, 30.0]
+
+
+def test_empty_cutoffs() -> None:
+    """Test validation with empty cutoffs."""
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(
+            starting_points=[{"lon": 11.123, "lat": 48.1234}],
+            cutoffs=[],
+            type="point",
+        )
+    assert "at least 1" in str(exc_info.value).lower()
+
+
+def test_too_many_cutoffs() -> None:
+    """Test validation with too many cutoffs."""
+    # Create 11 cutoffs (exceeds max of 10)
+    too_many_cutoffs = [float(i) for i in range(1, 12)]
+
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(
+            starting_points=[{"lon": 11.123, "lat": 48.1234}],
+            cutoffs=too_many_cutoffs,
+            type="point",
+        )
+    assert "at most 10" in str(exc_info.value).lower()
+
+
+def test_invalid_catchment_type() -> None:
+    """Test validation with invalid catchment type."""
+    with pytest.raises(ValidationError) as exc_info:
+        CatchmentSchema(
+            starting_points=[{"lon": 11.123, "lat": 48.1234}],
+            cutoffs=[10.0],
+            type="invalid_type",
+        )
+    assert "Input should be" in str(exc_info.value)
+
+
+def test_example_from_user_request() -> None:
+    """Test the exact example provided in the user request."""
+    data = {
+        "starting_points": [
+            {"lon": 11.123, "lat": 12.34},
+            {"lon": 48.11, "lat": 48.1234},
+        ],
+        "cutoffs": [10.0, 20.0, 30.0],
+        "type": "polygon",
+    }
+
+    schema = CatchmentSchema(**data)
+    assert len(schema.starting_points) == 2
+    assert schema.starting_points[0].lon == 11.123
+    assert schema.starting_points[0].lat == 12.34
+    assert schema.starting_points[1].lon == 48.11
+    assert schema.starting_points[1].lat == 48.1234
+    assert schema.cutoffs == [10.0, 20.0, 30.0]
+    assert schema.type == CatchmentAreaType.polygon
+
+
+"""Test cases for CatchmentAreaType enum."""
+
+
+def test_all_catchment_types_available() -> None:
+    """Test that all expected catchment types are available."""
+    expected_types = {"point", "network", "grid", "polygon"}
+    available_types = {t.value for t in CatchmentAreaType}
+    assert available_types == expected_types
diff --git a/packages/python/goatlib/tests/unit/routing/test_catchment_area_transit.py b/packages/python/goatlib/tests/unit/routing/test_catchment_area_transit.py
index e0fe50e92..85aa70e06 100644
--- a/packages/python/goatlib/tests/unit/routing/test_catchment_area_transit.py
+++ b/packages/python/goatlib/tests/unit/routing/test_catchment_area_transit.py
@@ -12,18 +12,16 @@
 
 def test_valid_single_point() -> None:
     """Test creating valid single starting point."""
-    starting_points = TransitCatchmentAreaStartingPoints(
-        latitude=[52.5200], longitude=[13.4050]
-    )
-    assert starting_points.latitude == [52.5200]
-    assert starting_points.longitude == [13.4050]
+    starting_points = TransitCatchmentAreaStartingPoints(lat=[52.5200], lon=[13.4050])
+    assert starting_points.lat == [52.5200]
+    assert starting_points.lon == [13.4050]
 
 
 def test_reject_multiple_points() -> None:
     """Test that multiple starting points are rejected."""
-    with pytest.raises(ValueError, match="single starting point"):
+    with pytest.raises(ValueError, match="exactly one starting point"):
         TransitCatchmentAreaStartingPoints(
-            latitude=[52.5200, 52.5300], longitude=[13.4050, 13.4150]
+            lat=[52.5200, 52.5300], lon=[13.4050, 13.4150]
         )
 
 
@@ -38,7 +36,7 @@ def test_valid_travel_cost() -> None:
 
 def test_cutoffs_exceed_max_time() -> None:
     """Test that cutoffs exceeding max travel time are rejected."""
-    with pytest.raises(ValueError, match="exceeds maximum travel time"):
+    with pytest.raises(ValueError, match="exceed maximum travel time"):
         TransitCatchmentAreaTravelTimeCost(max_traveltime=30, cutoffs=[15, 45, 60])
 
 
@@ -57,10 +55,8 @@ def test_unsorted_cutoffs() -> None:
 def test_valid_request() -> None:
     """Test creating a valid transit isochrone request."""
     request_data = {
-        "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+        "starting_points": {"lat": [52.5200], "lon": [13.4050]},
         "transit_modes": ["bus", "tram"],
-        "access_mode": "walk",
-        "egress_mode": "walk",
         "travel_cost": {
             "max_traveltime": 60,
             "cutoffs": [15, 30, 45, 60],
@@ -68,7 +64,7 @@ def test_valid_request() -> None:
     }
 
     request = TransitCatchmentAreaRequest(**request_data)
-    assert len(request.starting_points.latitude) == 1
+    assert len(request.starting_points.lat) == 1
     assert len(request.transit_modes) == 2
     assert request.travel_cost.max_traveltime == 60
 
@@ -76,17 +72,17 @@ def test_valid_request() -> None:
 def test_bike_access_request() -> None:
     """Test transit request with bicycle access mode."""
     request_data = {
-        "starting_points": {"latitude": [52.5200], "longitude": [13.4050]},
+        "starting_points": {"lat": [52.5200], "lon": [13.4050]},
         "transit_modes": ["rail", "subway"],
-        "access_mode": "bicycle",
-        "egress_mode": "walk",
         "travel_cost": {"max_traveltime": 45, "cutoffs": [15, 30, 45]},
-        "routing_settings": {"bike_settings": {"max_time": 25}},
+        "routing_settings": {
+            "access_settings": {"mode": "bicycle", "max_time": 25, "speed": 15.0}
+        },
     }
 
     request = TransitCatchmentAreaRequest(**request_data)
     assert request.access_mode == AccessEgressMode.bicycle
-    assert request.routing_settings.bike_settings.max_time == 25
+    assert request.routing_settings.access_settings.max_time == 25
 
 
 def test_routing_settings() -> None:
@@ -95,25 +91,25 @@ def test_routing_settings() -> None:
 
     # Test default values
     assert routing_settings.max_transfers == 4
-    assert routing_settings.walk_settings.max_time == 15
-    assert routing_settings.walk_settings.speed == 5.0
-    assert routing_settings.bike_settings.max_time == 20
-    assert routing_settings.bike_settings.speed == 15.0
+    assert routing_settings.access_settings.max_time == 15
+    assert routing_settings.access_settings.speed == 5.0
+    assert routing_settings.egress_settings.max_time == 15
+    assert routing_settings.egress_settings.speed == 5.0
 
 
 def test_custom_routing_settings() -> None:
     """Test custom routing settings."""
     routing_settings = TransitRoutingSettings(
         max_transfers=6,
-        walk_settings={"max_time": 20, "speed": 4.5},
-        bike_settings={"max_time": 30, "speed": 18.0},
+        access_settings={"mode": "walk", "max_time": 20, "speed": 4.5},
+        egress_settings={"mode": "bicycle", "max_time": 30, "speed": 18.0},
     )
 
     assert routing_settings.max_transfers == 6
-    assert routing_settings.walk_settings.max_time == 20
-    assert routing_settings.walk_settings.speed == 4.5
-    assert routing_settings.bike_settings.max_time == 30
-    assert routing_settings.bike_settings.speed == 18.0
+    assert routing_settings.access_settings.max_time == 20
+    assert routing_settings.access_settings.speed == 4.5
+    assert routing_settings.egress_settings.max_time == 30
+    assert routing_settings.egress_settings.speed == 18.0
 
 
 def test_catchment_area_polygon() -> None:
diff --git a/packages/python/goatlib/tests/unit/routing/test_route_validation.py b/packages/python/goatlib/tests/unit/routing/test_route_validation.py
index b1cb29bde..b4856d482 100644
--- a/packages/python/goatlib/tests/unit/routing/test_route_validation.py
+++ b/packages/python/goatlib/tests/unit/routing/test_route_validation.py
@@ -1,7 +1,7 @@
 from datetime import datetime, timezone
 
 from goatlib.routing.schemas.ab_routing import ABLeg, ABRoute
-from goatlib.routing.schemas.base import Location, Mode
+from goatlib.routing.schemas.base import Coordinates, Mode
 from goatlib.routing.utils.ab_route_validator import (
     validate_route_response,
     validate_single_route,
@@ -10,14 +10,14 @@
 
 def create_sample_route() -> ABRoute:
     """Create a sample route for testing."""
-    origin = Location(lat=48.1351, lon=11.5820)  # Munich center
-    destination = Location(lat=48.1482, lon=11.5680)  # Munich north
+    origin = Coordinates(lat=48.1351, lon=11.5820)  # Munich center
+    destination = Coordinates(lat=48.1482, lon=11.5680)  # Munich north
 
     # Walking leg
     walk_leg = ABLeg(
         origin=origin,
-        destination=Location(lat=48.1360, lon=11.5810),  # Short walk to transit
-        mode=Mode.WALK,
+        destination=Coordinates(lat=48.1360, lon=11.5810),  # Short walk to transit
+        mode=Mode.walk,
         departure_time=datetime(2025, 12, 15, 9, 0, 0, tzinfo=timezone.utc),
         arrival_time=datetime(2025, 12, 15, 9, 5, 0, tzinfo=timezone.utc),
         duration=300,  # 5 minutes
@@ -26,9 +26,9 @@ def create_sample_route() -> ABRoute:
 
     # Transit leg
     transit_leg = ABLeg(
-        origin=Location(lat=48.1360, lon=11.5810),
-        destination=Location(lat=48.1480, lon=11.5675),
-        mode=Mode.SUBWAY,
+        origin=Coordinates(lat=48.1360, lon=11.5810),
+        destination=Coordinates(lat=48.1480, lon=11.5675),
+        mode=Mode.subway,
         departure_time=datetime(2025, 12, 15, 9, 8, 0, tzinfo=timezone.utc),
         arrival_time=datetime(2025, 12, 15, 9, 15, 0, tzinfo=timezone.utc),
         duration=420,  # 7 minutes
@@ -37,9 +37,9 @@ def create_sample_route() -> ABRoute:
 
     # Final walking leg
     final_walk = ABLeg(
-        origin=Location(lat=48.1480, lon=11.5675),
+        origin=Coordinates(lat=48.1480, lon=11.5675),
         destination=destination,
-        mode=Mode.WALK,
+        mode=Mode.walk,
         departure_time=datetime(2025, 12, 15, 9, 15, 0, tzinfo=timezone.utc),
         arrival_time=datetime(2025, 12, 15, 9, 18, 0, tzinfo=timezone.utc),
         duration=180,  # 3 minutes
@@ -61,14 +61,14 @@ def create_sample_route() -> ABRoute:
 
 def create_problematic_route() -> ABRoute:
     """Create a route with plausibility issues for testing."""
-    origin = Location(lat=48.1351, lon=11.5820)
-    destination = Location(lat=48.2000, lon=11.6000)  # Much further
+    origin = Coordinates(lat=48.1351, lon=11.5820)
+    destination = Coordinates(lat=48.2000, lon=11.6000)  # Much further
 
     # Impossibly fast walking
     bad_walk = ABLeg(
         origin=origin,
         destination=destination,
-        mode=Mode.WALK,
+        mode=Mode.walk,
         departure_time=datetime(2025, 12, 15, 9, 0, 0, tzinfo=timezone.utc),
         arrival_time=datetime(2025, 12, 15, 9, 5, 0, tzinfo=timezone.utc),
         duration=300,  # 5 minutes

From 1da4eca9aec58b2b2f35732cccd90306e579c109 Mon Sep 17 00:00:00 2001
From: 96hoshi <marta.locascio@plan4better.de>
Date: Tue, 9 Dec 2025 16:28:30 +0000
Subject: [PATCH 03/11] fix: updated benchmark tests

---
 .../benchmark_network_memory_usage.py         |   1 -
 .../goatlib/tests/benchmarks/conftest.py      | 144 ++++++++++++++++++
 .../test_motis_ab_routing_benchmark.py        | 122 +++++----------
 .../test_motis_one_to_all_benchmark.py        |  91 ++---------
 .../test_motis_one_to_all_plausibility.py     |  29 ++--
 5 files changed, 207 insertions(+), 180 deletions(-)
 create mode 100644 packages/python/goatlib/tests/benchmarks/conftest.py

diff --git a/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py b/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
index 518dbbbd7..8f7c9a841 100644
--- a/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
+++ b/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
@@ -3,7 +3,6 @@
 import time
 from pathlib import Path
 
-
 try:
     import psutil
 
diff --git a/packages/python/goatlib/tests/benchmarks/conftest.py b/packages/python/goatlib/tests/benchmarks/conftest.py
new file mode 100644
index 000000000..96c1880d5
--- /dev/null
+++ b/packages/python/goatlib/tests/benchmarks/conftest.py
@@ -0,0 +1,144 @@
+"""Common utilities and fixtures for routing benchmarks."""
+
+import json
+import time
+import tracemalloc
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import psutil
+
+
+class BenchmarkMetrics:
+    """Base class to track performance metrics during benchmark execution."""
+
+    def __init__(self) -> None:
+        self.reset()
+
+    def reset(self) -> None:
+        """Reset all metrics."""
+        self.timings: Dict[str, float] = {}
+        self.memory_usage: Dict[str, Dict[str, float]] = {}
+        self.response_stats: Dict[str, Any] = {}
+
+    def start_timing(self, phase: str) -> None:
+        """Start timing a specific phase."""
+        self.timings[f"{phase}_start"] = time.perf_counter()
+
+    def end_timing(self, phase: str) -> None:
+        """End timing a specific phase and calculate duration."""
+        end_time = time.perf_counter()
+        start_time = self.timings.get(f"{phase}_start", end_time)
+        self.timings[f"{phase}_duration"] = end_time - start_time
+
+    def record_memory(self, phase: str) -> None:
+        """Record memory usage at a specific phase."""
+        current, peak = tracemalloc.get_traced_memory()
+        process = psutil.Process()
+        self.memory_usage[phase] = {
+            "current_mb": current / 1024 / 1024,
+            "peak_mb": peak / 1024 / 1024,
+            "process_rss_mb": process.memory_info().rss / 1024 / 1024,
+        }
+
+    def get_duration(self, phase: str) -> Optional[float]:
+        """Get duration of a specific phase."""
+        return self.timings.get(f"{phase}_duration")
+
+    def get_total_duration(self) -> float:
+        """Calculate total duration from all recorded phases."""
+        return sum(v for k, v in self.timings.items() if k.endswith("_duration"))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert metrics to dictionary."""
+        return {
+            "timings": self.timings,
+            "memory_usage": self.memory_usage,
+            "response_stats": self.response_stats,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    def print_summary(self) -> None:
+        """Print a formatted summary of metrics."""
+        print("\n" + "=" * 60)
+        print("BENCHMARK SUMMARY")
+        print("=" * 60)
+
+        if self.timings:
+            print("\n⏱️  TIMINGS:")
+            for key, value in self.timings.items():
+                if key.endswith("_duration"):
+                    phase = key.replace("_duration", "")
+                    print(f"  {phase}: {value:.4f}s")
+
+        if self.memory_usage:
+            print("\n💾 MEMORY USAGE:")
+            for phase, stats in self.memory_usage.items():
+                print(f"  {phase}:")
+                print(f"    Current: {stats['current_mb']:.2f} MB")
+                print(f"    Peak: {stats['peak_mb']:.2f} MB")
+                print(f"    Process RSS: {stats['process_rss_mb']:.2f} MB")
+
+        if self.response_stats:
+            print("\n📊 RESPONSE STATS:")
+            for key, value in self.response_stats.items():
+                print(f"  {key}: {value}")
+
+        print("=" * 60 + "\n")
+
+
+def save_benchmark_results(
+    metrics: BenchmarkMetrics, test_name: str, output_dir: Optional[Path] = None
+) -> Path:
+    """
+    Save benchmark results to JSON file.
+
+    Args:
+        metrics: The metrics object to save
+        test_name: Name of the test for the filename
+        output_dir: Optional custom output directory. Defaults to benchmarks/results
+
+    Returns:
+        Path to the saved file
+    """
+    if output_dir is None:
+        output_dir = Path(__file__).parent / "results"
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"{test_name}_{timestamp}.json"
+    filepath = output_dir / filename
+
+    with open(filepath, "w") as f:
+        json.dump(metrics.to_dict(), f, indent=2)
+
+    print(f"\n📁 Benchmark results saved to: {filepath}")
+    return filepath
+
+
+def format_duration(seconds: float) -> str:
+    """Format duration in seconds to human-readable string."""
+    if seconds < 0.001:
+        return f"{seconds * 1_000_000:.2f}µs"
+    elif seconds < 1:
+        return f"{seconds * 1000:.2f}ms"
+    elif seconds < 60:
+        return f"{seconds:.2f}s"
+    else:
+        minutes = int(seconds // 60)
+        secs = seconds % 60
+        return f"{minutes}m {secs:.2f}s"
+
+
+def format_memory(bytes_value: float) -> str:
+    """Format memory in bytes to human-readable string."""
+    if bytes_value < 1024:
+        return f"{bytes_value:.2f}B"
+    elif bytes_value < 1024**2:
+        return f"{bytes_value / 1024:.2f}KB"
+    elif bytes_value < 1024**3:
+        return f"{bytes_value / (1024**2):.2f}MB"
+    else:
+        return f"{bytes_value / (1024**3):.2f}GB"
diff --git a/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py b/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py
index 8493c2169..4dd629743 100644
--- a/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py
+++ b/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py
@@ -1,53 +1,24 @@
-import json
-import time
 import tracemalloc
-from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict
 
 import psutil
 from goatlib.routing.adapters.motis import create_motis_adapter
 from goatlib.routing.schemas.ab_routing import ABRoutingRequest, ABRoutingResponse
-from goatlib.routing.schemas.base import Location, Mode
+from goatlib.routing.schemas.base import Coordinates, Mode
 
+from .conftest import BenchmarkMetrics, save_benchmark_results
 
-class ABRoutingPerformanceMetrics:
+
+class ABRoutingBenchmarkMetrics(BenchmarkMetrics):
     """Class to track AB routing performance metrics during test execution."""
 
-    def __init__(self: "ABRoutingPerformanceMetrics") -> None:
-        self.reset()
-
-    def reset(self: "ABRoutingPerformanceMetrics") -> None:
-        """Reset all metrics."""
-        self.timings = {}
-        self.memory_usage = {}
-        self.network_stats = {}
-        self.response_stats = {}
-        self.validation_stats = {}
-
-    def start_timing(self: "ABRoutingPerformanceMetrics", phase: str) -> None:
-        """Start timing a specific phase."""
-        self.timings[f"{phase}_start"] = time.perf_counter()
-
-    def end_timing(self: "ABRoutingPerformanceMetrics", phase: str) -> None:
-        """End timing a specific phase and calculate duration."""
-        end_time = time.perf_counter()
-        start_time = self.timings.get(f"{phase}_start", end_time)
-        self.timings[f"{phase}_duration"] = end_time - start_time
-
-    def record_memory(self: "ABRoutingPerformanceMetrics", phase: str) -> None:
-        """Record memory usage at a specific phase."""
-        current, peak = tracemalloc.get_traced_memory()
-        self.memory_usage[phase] = {
-            "current_mb": current / 1024 / 1024,
-            "peak_mb": peak / 1024 / 1024,
-            "process_rss_mb": psutil.Process().memory_info().rss / 1024 / 1024,
-        }
+    def __init__(self) -> None:
+        super().__init__()
+        self.validation_stats: Dict[str, Any] = {}
 
     def record_response_stats(
-        self: "ABRoutingPerformanceMetrics",
-        response: ABRoutingResponse,
-        request: ABRoutingRequest,
+        self, response: ABRoutingResponse, request: ABRoutingRequest
     ) -> None:
         """Record AB routing response statistics."""
         route_count = len(response.routes)
@@ -64,13 +35,13 @@ def record_response_stats(
         for route in response.routes:
             for leg in route.legs:
                 modes_used.add(leg.mode.value)
-                if leg.mode == Mode.WALK:
+                if leg.mode == Mode.walk:
                     walking_legs += 1
                 else:
                     transit_legs += 1
             # Count transfers (transitions between transit modes)
             transit_modes_in_route = [
-                leg.mode for leg in route.legs if leg.mode != Mode.WALK
+                leg.mode for leg in route.legs if leg.mode != Mode.walk
             ]
             if len(transit_modes_in_route) > 1:
                 transfer_count += len(transit_modes_in_route) - 1
@@ -95,9 +66,7 @@ def record_response_stats(
             "transport_modes_requested": [mode.value for mode in request.modes],
         }
 
-    def record_validation_stats(
-        self: "ABRoutingPerformanceMetrics", response: ABRoutingResponse
-    ) -> None:
+    def record_validation_stats(self, response: ABRoutingResponse) -> None:
         """Record comprehensive plausibility validation statistics."""
         from goatlib.routing.utils.ab_route_validator import (
             validate_route_response,
@@ -166,32 +135,9 @@ def record_validation_stats(
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert metrics to dictionary."""
-        return {
-            "timings": self.timings,
-            "memory_usage": self.memory_usage,
-            "network_stats": self.network_stats,
-            "response_stats": self.response_stats,
-            "validation_stats": self.validation_stats,
-            "timestamp": datetime.now().isoformat(),
-        }
-
-
-def save_ab_routing_benchmark_results(
-    metrics: ABRoutingPerformanceMetrics, test_name: str
-) -> Path:
-    """Save AB routing benchmark results to JSON file."""
-    benchmark_dir = Path(__file__).parent / "results"
-    benchmark_dir.mkdir(exist_ok=True)
-
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename = f"{test_name}_{timestamp}.json"
-    filepath = benchmark_dir / filename
-
-    with open(filepath, "w") as f:
-        json.dump(metrics.to_dict(), f, indent=2)
-
-    print(f"\n📊 AB Routing benchmark results saved to: {filepath}")
-    return filepath
+        base_dict = super().to_dict()
+        base_dict["validation_stats"] = self.validation_stats
+        return base_dict
 
 
 def validate_ab_routing_response(response: ABRoutingResponse) -> None:
@@ -229,11 +175,11 @@ async def test_motis_ab_routing_performance_benchmark():
     - Pre-request preparation time
     - Network request time
     - Post-processing time
-    - Memory allocation
+    - Memory alCoordinates
     - Response data analysis
     - Route validation performance
     """
-    metrics = ABRoutingPerformanceMetrics()
+    metrics = ABRoutingBenchmarkMetrics()
 
     # Start memory tracing
     tracemalloc.start()
@@ -248,9 +194,11 @@ async def test_motis_ab_routing_performance_benchmark():
 
         # Create comprehensive routing request (Munich to Stuttgart - major city pair)
         request = ABRoutingRequest(
-            origin=Location(lat=48.1351, lon=11.5820),  # Munich central station
-            destination=Location(lat=48.7758, lon=9.1829),  # Stuttgart central station
-            modes=[Mode.TRANSIT, Mode.WALK],  # Allow transfers and walking
+            origin=Coordinates(lat=48.1351, lon=11.5820),  # Munich central station
+            destination=Coordinates(
+                lat=48.7758, lon=9.1829
+            ),  # Stuttgart central station
+            modes=[Mode.transit, Mode.walk],  # Allow transfers and walking
             max_results=5,  # Request multiple alternatives
             max_transfers=3,  # Allow up to 3 transfers for complex routes
             max_walking_distance=1000,  # 1km max walking distance
@@ -295,8 +243,8 @@ async def test_motis_ab_routing_performance_benchmark():
         # Detailed route analysis (typical use case processing)
         for route in response.routes:
             # Analyze route characteristics
-            transit_legs = [leg for leg in route.legs if leg.mode != Mode.WALK]
-            walking_legs = [leg for leg in route.legs if leg.mode == Mode.WALK]
+            transit_legs = [leg for leg in route.legs if leg.mode != Mode.walk]
+            walking_legs = [leg for leg in route.legs if leg.mode == Mode.walk]
 
             # Validate route connectivity
             for i in range(len(route.legs) - 1):
@@ -316,9 +264,7 @@ async def test_motis_ab_routing_performance_benchmark():
         metrics.end_timing("validation")
 
         # === SAVE RESULTS ===
-        filepath = save_ab_routing_benchmark_results(
-            metrics, "motis_ab_routing_performance"
-        )
+        filepath = save_benchmark_results(metrics, "motis_ab_routing_performance")
 
         # === PRINT DETAILED SUMMARY ===
         print("\n🚀 MOTIS AB Routing Performance Benchmark Results:")
@@ -415,7 +361,7 @@ async def test_motis_ab_routing_minimal_benchmark():
     Minimal benchmark for quick AB routing performance checks.
     Tests short-distance urban routing scenario.
     """
-    metrics = ABRoutingPerformanceMetrics()
+    metrics = ABRoutingBenchmarkMetrics()
     tracemalloc.start()
 
     try:
@@ -426,9 +372,9 @@ async def test_motis_ab_routing_minimal_benchmark():
 
         # Berlin local routing (Alexanderplatz to Brandenburg Gate)
         request = ABRoutingRequest(
-            origin=Location(lat=52.5219, lon=13.4132),  # Alexanderplatz
-            destination=Location(lat=52.5163, lon=13.3777),  # Brandenburg Gate
-            modes=[Mode.TRANSIT, Mode.WALK],
+            origin=Coordinates(lat=52.5219, lon=13.4132),  # Alexanderplatz
+            destination=Coordinates(lat=52.5163, lon=13.3777),  # Brandenburg Gate
+            modes=[Mode.transit, Mode.walk],
             max_results=2,  # Minimal results for fast response
             max_transfers=1,  # Single transfer max
         )
@@ -441,7 +387,7 @@ async def test_motis_ab_routing_minimal_benchmark():
         metrics.record_validation_stats(response)
 
         # Save minimal results
-        save_ab_routing_benchmark_results(metrics, "motis_ab_routing_minimal")
+        save_benchmark_results(metrics, "motis_ab_routing_minimal")
 
         print("\n⚡ Minimal AB Routing Benchmark:")
         print(f"   Total time:      {metrics.timings.get('total_duration', 0):.3f}s")
@@ -474,7 +420,7 @@ async def test_motis_ab_routing_stress_benchmark():
     Stress test benchmark for AB routing with challenging parameters.
     Tests maximum complexity routing scenario.
     """
-    metrics = ABRoutingPerformanceMetrics()
+    metrics = ABRoutingBenchmarkMetrics()
     tracemalloc.start()
 
     try:
@@ -485,9 +431,9 @@ async def test_motis_ab_routing_stress_benchmark():
 
         # Long-distance routing with maximum complexity (Berlin to Munich)
         request = ABRoutingRequest(
-            origin=Location(lat=52.5200, lon=13.4050),  # Berlin
-            destination=Location(lat=48.1351, lon=11.5820),  # Munich
-            modes=[Mode.TRANSIT, Mode.WALK],
+            origin=Coordinates(lat=52.5200, lon=13.4050),  # Berlin
+            destination=Coordinates(lat=48.1351, lon=11.5820),  # Munich
+            modes=[Mode.transit, Mode.walk],
             max_results=10,  # Maximum results
             max_transfers=5,  # Allow many transfers
             max_walking_distance=2000,  # Longer walking distance
@@ -501,7 +447,7 @@ async def test_motis_ab_routing_stress_benchmark():
         metrics.record_validation_stats(response)
 
         # Save stress test results
-        save_ab_routing_benchmark_results(metrics, "motis_ab_routing_stress")
+        save_benchmark_results(metrics, "motis_ab_routing_stress")
 
         print("\n🔥 Stress Test AB Routing Benchmark:")
         print(f"   Total time:      {metrics.timings.get('total_duration', 0):.3f}s")
diff --git a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py b/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py
index ef0dbe826..fcac9a411 100644
--- a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py
+++ b/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py
@@ -1,52 +1,19 @@
-import json
-import time
 import tracemalloc
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict
 
 import psutil
 from goatlib.routing.adapters.motis import create_motis_adapter
+from goatlib.routing.schemas.base import AccessEgressMode, CatchmentAreaRoutingModePT
 from goatlib.routing.schemas.catchment_area_transit import (
-    AccessEgressMode,
-    CatchmentAreaRoutingModePT,
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaStartingPoints,
-    TransitCatchmentAreaTravelTimeCost,
+    TravelTimeCost,
 )
 
+from .conftest import BenchmarkMetrics, save_benchmark_results
 
-class PerformanceMetrics:
-    """Class to track performance metrics during test execution."""
-
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        """Reset all metrics."""
-        self.timings = {}
-        self.memory_usage = {}
-        self.network_stats = {}
-        self.response_stats = {}
-
-    def start_timing(self, phase: str):
-        """Start timing a specific phase."""
-        self.timings[f"{phase}_start"] = time.perf_counter()
-
-    def end_timing(self, phase: str):
-        """End timing a specific phase and calculate duration."""
-        end_time = time.perf_counter()
-        start_time = self.timings.get(f"{phase}_start", end_time)
-        self.timings[f"{phase}_duration"] = end_time - start_time
-
-    def record_memory(self, phase: str):
-        """Record memory usage at a specific phase."""
-        current, peak = tracemalloc.get_traced_memory()
-        self.memory_usage[phase] = {
-            "current_mb": current / 1024 / 1024,
-            "peak_mb": peak / 1024 / 1024,
-            "process_rss_mb": psutil.Process().memory_info().rss / 1024 / 1024,
-        }
+
+class OneToAllBenchmarkMetrics(BenchmarkMetrics):
+    """Class to track one-to-all performance metrics during test execution."""
 
     def record_response_stats(self, response, request):
         """Record response statistics."""
@@ -68,32 +35,6 @@ def record_response_stats(self, response, request):
             "transit_modes": len(request.transit_modes),
         }
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert metrics to dictionary."""
-        return {
-            "timings": self.timings,
-            "memory_usage": self.memory_usage,
-            "network_stats": self.network_stats,
-            "response_stats": self.response_stats,
-            "timestamp": datetime.now().isoformat(),
-        }
-
-
-def save_benchmark_results(metrics: PerformanceMetrics, test_name: str):
-    """Save benchmark results to JSON file."""
-    benchmark_dir = Path(__file__).parent / "results"
-    benchmark_dir.mkdir(exist_ok=True)
-
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename = f"{test_name}_{timestamp}.json"
-    filepath = benchmark_dir / filename
-
-    with open(filepath, "w") as f:
-        json.dump(metrics.to_dict(), f, indent=2)
-
-    print(f"\n📊 Benchmark results saved to: {filepath}")
-    return filepath
-
 
 async def test_motis_one_to_all_performance_benchmark():
     """
@@ -106,7 +47,7 @@ async def test_motis_one_to_all_performance_benchmark():
     - Memory allocation
     - Response data size
     """
-    metrics = PerformanceMetrics()
+    metrics = OneToAllBenchmarkMetrics()
 
     # Start memory tracing
     tracemalloc.start()
@@ -120,11 +61,12 @@ async def test_motis_one_to_all_performance_benchmark():
         adapter = create_motis_adapter(use_fixtures=False)
 
         # Create request (Berlin with multiple cutoffs for substantial response)
+        starting_points = TransitCatchmentAreaStartingPoints(
+            lat=[52.5200],
+            lon=[13.4050],  # Berlin center
+        )
         request = TransitCatchmentAreaRequest(
-            starting_points=TransitCatchmentAreaStartingPoints(
-                latitude=[52.5200],  # Berlin center
-                longitude=[13.4050],
-            ),
+            starting_points=starting_points,
             transit_modes=[
                 CatchmentAreaRoutingModePT.bus,
                 CatchmentAreaRoutingModePT.tram,
@@ -133,7 +75,7 @@ async def test_motis_one_to_all_performance_benchmark():
             ],
             access_mode=AccessEgressMode.walk,
             egress_mode=AccessEgressMode.walk,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
+            travel_cost=TravelTimeCost(
                 max_traveltime=45,
                 cutoffs=[15, 30, 45],  # Multiple cutoffs for larger response
             ),
@@ -251,7 +193,7 @@ async def test_motis_one_to_all_minimal_benchmark():
     """
     Minimal benchmark for quick performance checks.
     """
-    metrics = PerformanceMetrics()
+    metrics = OneToAllBenchmarkMetrics()
     tracemalloc.start()
 
     try:
@@ -262,13 +204,12 @@ async def test_motis_one_to_all_minimal_benchmark():
 
         request = TransitCatchmentAreaRequest(
             starting_points=TransitCatchmentAreaStartingPoints(
-                latitude=[52.5200],
-                longitude=[13.4050],
+                lat=[52.5200], lon=[13.4050]
             ),
             transit_modes=[CatchmentAreaRoutingModePT.subway],
             access_mode=AccessEgressMode.walk,
             egress_mode=AccessEgressMode.walk,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
+            travel_cost=TravelTimeCost(
                 max_traveltime=15,
                 cutoffs=[15],
             ),
diff --git a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_plausibility.py b/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_plausibility.py
index 85aec25da..ae3e4b168 100644
--- a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_plausibility.py
+++ b/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_plausibility.py
@@ -9,17 +9,14 @@
     parse_motis_one_to_all_response,
     translate_to_motis_one_to_all_request,
 )
+from goatlib.routing.schemas.base import AccessEgressMode, CatchmentAreaRoutingModePT
 from goatlib.routing.schemas.catchment_area_transit import (
-    AccessEgressMode,
-    CatchmentAreaRoutingModePT,
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaStartingPoints,
-    TransitCatchmentAreaTravelTimeCost,
     TransitRoutingSettings,
+    TravelTimeCost,
 )
 
-# Set up logging to see detailed output
-logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
@@ -133,8 +130,8 @@ async def run_comprehensive_test(self) -> Dict[str, Any]:
             # Create test request
             request = TransitCatchmentAreaRequest(
                 starting_points=TransitCatchmentAreaStartingPoints(
-                    latitude=[48.1351],
-                    longitude=[11.5820],
+                    lat=[48.1351],
+                    lon=[11.5820],
                 ),
                 transit_modes=[
                     CatchmentAreaRoutingModePT.bus,
@@ -142,7 +139,7 @@ async def run_comprehensive_test(self) -> Dict[str, Any]:
                 ],
                 access_mode=AccessEgressMode.walk,
                 egress_mode=AccessEgressMode.walk,
-                travel_cost=TransitCatchmentAreaTravelTimeCost(
+                travel_cost=TravelTimeCost(
                     max_traveltime=30,
                     cutoffs=[10, 20, 30],
                 ),
@@ -191,8 +188,8 @@ async def run_comprehensive_test(self) -> Dict[str, Any]:
                 "test_location": "Munich, Germany",
                 "request_params": {
                     "starting_point": [
-                        request.starting_points.latitude[0],
-                        request.starting_points.longitude[0],
+                        request.starting_points.lat[0],
+                        request.starting_points.lon[0],
                     ],
                     "transit_modes": [mode.value for mode in request.transit_modes],
                     "max_travel_time": request.travel_cost.max_traveltime,
@@ -252,8 +249,8 @@ def sample_request():
     """Fixture providing a sample transit catchment area request."""
     return TransitCatchmentAreaRequest(
         starting_points=TransitCatchmentAreaStartingPoints(
-            latitude=[48.1351],
-            longitude=[11.5820],  # Munich city center
+            lat=[48.1351],
+            lon=[11.5820],  # Munich city center
         ),
         transit_modes=[
             CatchmentAreaRoutingModePT.bus,
@@ -261,7 +258,7 @@ def sample_request():
         ],
         access_mode=AccessEgressMode.walk,
         egress_mode=AccessEgressMode.walk,
-        travel_cost=TransitCatchmentAreaTravelTimeCost(
+        travel_cost=TravelTimeCost(
             max_traveltime=30,
             cutoffs=[10, 20, 30],
         ),
@@ -277,11 +274,11 @@ async def test_motis_one_to_all_raw_response_validation(plausibility_tester):
     try:
         request = TransitCatchmentAreaRequest(
             starting_points=TransitCatchmentAreaStartingPoints(
-                latitude=[48.1351],
-                longitude=[11.5820],
+                lat=[48.1351],
+                lon=[11.5820],
             ),
             transit_modes=[CatchmentAreaRoutingModePT.bus],
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
+            travel_cost=TravelTimeCost(
                 max_traveltime=20,
                 cutoffs=[10, 20],
             ),

From cf7e1608176272a5b0bbca33e3efd0728f5d02f8 Mon Sep 17 00:00:00 2001
From: 96hoshi <marta.locascio@plan4better.de>
Date: Wed, 10 Dec 2025 17:00:31 +0000
Subject: [PATCH 04/11] wip: refactoring split_edge logic

---
 .../analysis/network/network_processor.py     | 243 ++++++++++++----
 .../routing/adapters/motis/motis_adapter.py   |  73 ++++-
 .../routing/adapters/motis/motis_client.py    |  32 ++-
 .../adapters/motis/motis_converters.py        |  15 +-
 .../goatlib/src/goatlib/routing/errors.py     |   6 +
 .../src/goatlib/routing/schemas/catchment.py  |   3 +-
 .../routing/schemas/catchment_area_transit.py |  17 +-
 .../test_motis_ab_routing_benchmark.py        |   1 -
 .../test_motis_one_to_all_benchmark.py        |   6 +-
 .../test_motis_one_to_all_plausibility.py     |   8 +-
 .../tests/integration/network/conftest.py     |  12 -
 .../network/test_edge_splitting.py            | 162 -----------
 .../integration/network/test_interpolation.py | 130 ---------
 .../network/test_network_operations.py        | 162 -----------
 .../network/test_network_preprocessing.py     | 221 ++++++++++++++
 .../{ => ab}/test_motis_adapter_edge_cases.py |   0
 .../{ => ab}/test_motis_adapter_errors.py     |   0
 .../{ => ab}/test_motis_adapter_fixture.py    |   0
 .../{ => ab}/test_motis_adapter_online.py     |   0
 .../test_motis_adapter_one_to_all.py          |  18 +-
 .../test_motis_bus_station_buffers.py         |   4 +-
 .../tests/integration/routing/conftest.py     |   8 +-
 .../tests/unit/analysis/test_network.py       | 269 ++++++++++++++++++
 .../tests/unit/routing/test_catchment.py      |  72 ++---
 .../unit/routing/test_route_validation.py     |   3 +-
 .../routing => tests}/utils/__init__.py       |   0
 .../utils/ab_route_validator.py               |   0
 27 files changed, 826 insertions(+), 639 deletions(-)
 delete mode 100644 packages/python/goatlib/tests/integration/network/conftest.py
 delete mode 100644 packages/python/goatlib/tests/integration/network/test_edge_splitting.py
 delete mode 100644 packages/python/goatlib/tests/integration/network/test_interpolation.py
 delete mode 100644 packages/python/goatlib/tests/integration/network/test_network_operations.py
 create mode 100644 packages/python/goatlib/tests/integration/network/test_network_preprocessing.py
 rename packages/python/goatlib/tests/integration/routing/{ => ab}/test_motis_adapter_edge_cases.py (100%)
 rename packages/python/goatlib/tests/integration/routing/{ => ab}/test_motis_adapter_errors.py (100%)
 rename packages/python/goatlib/tests/integration/routing/{ => ab}/test_motis_adapter_fixture.py (100%)
 rename packages/python/goatlib/tests/integration/routing/{ => ab}/test_motis_adapter_online.py (100%)
 rename packages/python/goatlib/tests/integration/routing/{ => catchment}/test_motis_adapter_one_to_all.py (92%)
 rename packages/python/goatlib/tests/integration/routing/{ => catchment}/test_motis_bus_station_buffers.py (98%)
 create mode 100644 packages/python/goatlib/tests/unit/analysis/test_network.py
 rename packages/python/goatlib/{src/goatlib/routing => tests}/utils/__init__.py (100%)
 rename packages/python/goatlib/{src/goatlib/routing => tests}/utils/ab_route_validator.py (100%)

diff --git a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
index ee839a2bf..284197293 100644
--- a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
+++ b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
@@ -7,30 +7,26 @@
 
 logger = logging.getLogger(__name__)
 
+# from .super I have only: cleanup, init and import_input
+# TODO make it dependent by a coordinate pair to buffer the network area around it
+
 
 class InMemoryNetworkProcessor(AnalysisTool):
     """
     High-performance in-memory network processor for routing.
-
-    The recommended usage is via the context manager pattern, which guarantees
-    that all resources are safely cleaned up.
-
-    Example:
-        with InMemoryNetworkProcessor("/path/to/network.parquet") as proc:
-            # The network is loaded and ready.
-            # ... perform operations on the network ...
     """
 
     def __init__(self, input_path: str) -> None:
         """Initializes the processor. Requires network parameters to be valid."""
-        super().__init__(db_path=":memory:")
+        super().__init__(db_path=input_path)
         self.input_path = input_path
         self.network_table_name = None
         self._is_loaded = False
 
     def __enter__(self) -> "InMemoryNetworkProcessor":
         """Enters the context, loading the network and returning the processor instance."""
-        self._load_network()
+        # Don't load network yet - wait for user to call create_buffered_subset
+        # This allows working with only a subset of the network for performance
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb) -> None:
@@ -38,21 +34,14 @@ def __exit__(self, exc_type, exc_val, exc_tb) -> None:
         super().cleanup()
 
     # Public API Methods
-    def get_network_metadata(self) -> dict:
+    def get_network_metadata(self) -> Metadata:
         """Get metadata about the loaded network using AnalysisTool metadata functionality."""
         self._ensure_loaded()
-        return {
-            "geometry_column": self.meta.geometry_column,
-            "geometry_type": self.meta.geometry_type,
-            "crs": self.meta.crs,
-            "columns": [
-                {"name": col.name, "type": col.type} for col in self.meta.columns
-            ],
-            "table_name": self.network_table_name,
-        }
+        return self.meta
 
     def get_network_stats(self, table_name: str = None) -> Dict[str, Any]:
         """Get basic statistics about the network."""
+        self._ensure_loaded()
         target_table = table_name or self.network_table_name
         result = self.con.execute(f"""
             SELECT
@@ -73,16 +62,143 @@ def get_network_stats(self, table_name: str = None) -> Dict[str, Any]:
         }
 
     def get_available_tables(self) -> list[str]:
-        """Get list of available table names in the database."""
         result = self.con.execute("SHOW TABLES").fetchall()
-        return [table[0] for table in result]
+        return [row[0] for row in result]
+
+    def create_buffered_subset(
+        self,
+        latitude: float,
+        longitude: float,
+        buffer_radius: float = 5000.0,
+        base_table: str = None,
+    ) -> str:
+        """
+        Create a subset of the network within a buffer around a point.
+        This dramatically reduces memory and processing time for local operations.
+
+        Use this method BEFORE performing expensive operations like splitting or
+        interpolation to work only with relevant network edges.
+
+        Args:
+            latitude: Center point latitude
+            longitude: Center point longitude
+            buffer_radius: Buffer distance in meters (default: 5km)
+            base_table: Source table (defaults to main network table)
+
+        Returns:
+            Name of the created subset table
+
+        Example:
+            >>> processor = InMemoryNetworkProcessor("network.parquet")
+            >>> # Load network and create 3km subset around Munich center
+            >>> subset = processor.create_buffered_subset(48.1351, 11.5820, 3000)
+            >>> # Get metadata with statistics
+            >>> meta = processor.get_subset_metadata(subset, 48.1351, 11.5820, 3000)
+            >>> # Now work only on the subset (much faster!)
+            >>> split, _ = processor.split_edge_at_point(48.135, 11.582, base_table=subset)
+        """
+        self._ensure_loaded()
+        source_table = base_table or self.network_table_name
+        subset_table_name = f"buffered_network_{uuid.uuid4().hex[:8]}"
+        geom_col = self.meta.geometry_column
+
+        # Create point and buffer using DuckDB spatial functions
+        subset_query = f"""
+        CREATE TABLE {subset_table_name} AS
+        WITH buffer_geom AS (
+            SELECT ST_Buffer(
+                ST_Point({longitude}, {latitude}),
+                {buffer_radius}
+            ) AS buffer
+        )
+        SELECT t.*
+        FROM {source_table} t, buffer_geom
+        WHERE ST_Intersects(t.{geom_col}, buffer_geom.buffer)
+        """
+
+        self.con.execute(subset_query)
+
+        # Get basic edge count for logging
+        edge_count = self.con.execute(
+            f"SELECT COUNT(*) FROM {subset_table_name}"
+        ).fetchone()[0]
+        original_count = self.con.execute(
+            f"SELECT COUNT(*) FROM {source_table}"
+        ).fetchone()[0]
+
+        logger.info(
+            f"Created buffered subset: {edge_count}/{original_count} edges "
+            f"({edge_count/original_count*100:.1f}% of original) "
+            f"within {buffer_radius}m of ({latitude}, {longitude})"
+        )
+
+        return subset_table_name
+
+    def get_subset_metadata(
+        self,
+        subset_table: str,
+        latitude: float,
+        longitude: float,
+        buffer_radius: float,
+        source_table: str = None,
+    ) -> Metadata:
+        """
+        Get metadata for a buffered subset table with detailed statistics.
+
+        Args:
+            subset_table: Name of the subset table
+            latitude: Center point latitude used for buffer
+            longitude: Center point longitude used for buffer
+            buffer_radius: Buffer radius in meters
+            source_table: Original source table (defaults to main network table)
+
+        Returns:
+            Metadata object with buffer operation details in raw_meta
+        """
+        self._ensure_loaded()
+        source_table = source_table or self.network_table_name
+        geom_col = self.meta.geometry_column
+
+        # Create metadata for subset table
+        subset_meta = self._create_metadata_from_template(subset_table)
+
+        # Get statistics about the subset
+        stats_query = f"""
+        SELECT
+            COUNT(*) as subset_edges,
+            (SELECT COUNT(*) FROM {source_table}) as original_edges,
+            SUM(length_m) as total_length_m,
+            MIN(ST_Distance({geom_col}, ST_Point({longitude}, {latitude}))) as min_distance,
+            MAX(ST_Distance({geom_col}, ST_Point({longitude}, {latitude}))) as max_distance
+        FROM {subset_table}
+        """
+
+        stats_result = self.con.execute(stats_query).fetchone()
+
+        # Add buffer operation details to metadata
+        subset_meta.raw_meta = subset_meta.raw_meta or {}
+        subset_meta.raw_meta["buffer_operation"] = {
+            "operation": "spatial_buffer",
+            "center_point": {"lat": latitude, "lon": longitude},
+            "buffer_radius_m": buffer_radius,
+            "original_edge_count": stats_result[1],
+            "subset_edge_count": stats_result[0],
+            "reduction_ratio": stats_result[0] / stats_result[1]
+            if stats_result[1] > 0
+            else 0,
+            "total_length_m": float(stats_result[2]) if stats_result[2] else 0,
+            "min_distance_m": float(stats_result[3]) if stats_result[3] else 0,
+            "max_distance_m": float(stats_result[4]) if stats_result[4] else 0,
+        }
+
+        return subset_meta
 
     def apply_sql_query(
-        self, sql_query: str, result_table_prefix: str = "query_result"
+        self, sql_query: str, result_table: str = "query_result"
     ) -> str:
         """Applies SQL and returns a NEW table, without destroying the input."""
         self._ensure_loaded()
-        result_table = self._generate_table_name(result_table_prefix)
+        result_table = f"{result_table}_{uuid.uuid4().hex[:8]}"
         try:
             # WARNING: This does not sanitize input SQL - use with caution in production
             self.con.execute(f"CREATE TABLE {result_table} AS {sql_query}")
@@ -118,7 +234,7 @@ def split_edge_at_point(
         """
         self._ensure_loaded()
         source_table = base_table or self.network_table_name
-        split_table_name = self._generate_table_name("split_network")
+        split_table_name = f"split_network_{uuid.uuid4().hex[:8]}"
         new_node_id = f"split_node_{uuid.uuid4().hex[:8]}"
         point_geom = f"ST_Point({longitude}, {latitude})"
         geom_col = self.meta.geometry_column
@@ -370,52 +486,66 @@ def interpolate_long_edges(
         return interpolated_table, interpolated_meta
 
     # File I/O Methods
-    def save_table_to_file(
-        self, table_name: str, output_path: str, format: str = "PARQUET"
-    ) -> None:
-        """Save table to file with preserved geometry. Supports PARQUET, GPKG, etc."""
-        if format.upper() == "PARQUET":
+    def save_table(
+        self,
+        table_name: str,
+        output_path: str | None = None,
+        format: str = "PARQUET",
+    ) -> str:
+        import tempfile
+
+        def quote_ident(name: str) -> str:
+            return '"' + name.replace('"', '""') + '"'
+
+        format_upper = format.upper()
+        table = quote_ident(table_name)
+
+        if output_path is None:
+            suffix = ".parquet" if format_upper == "PARQUET" else ".gpkg"
+            with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
+                output_path = tmp.name
+
+        if format_upper == "PARQUET":
             self.con.execute(
-                f"COPY {table_name} TO '{output_path}' (FORMAT PARQUET, COMPRESSION ZSTD)"
+                f"""
+                COPY {table} TO '{output_path}'
+                (
+                    FORMAT PARQUET,
+                    COMPRESSION ZSTD,
+                    ROW_GROUP_SIZE 1000000
+                )
+                """
             )
         else:
-            # Use DuckDB's spatial export for other formats
             self.con.execute(
-                f"COPY {table_name} TO '{output_path}' WITH (FORMAT GDAL, DRIVER '{format}')"
+                f"""
+                COPY {table} TO '{output_path}'
+                (
+                    FORMAT GDAL,
+                    DRIVER '{format_upper}'
+                )
+                """
             )
 
-    def save_table_to_tmp(self, table_name: str, format: str = "PARQUET") -> str:
-        """Save table to a temporary file and return the path."""
-        import tempfile
-
-        suffix = ".parquet" if format.upper() == "PARQUET" else ".gpkg"
-        with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp_file:
-            output_path = tmp_file.name
-        self.save_table_to_file(table_name, output_path, format)
         return output_path
 
     # Private Helper Methods
     def _ensure_loaded(self) -> None:
         if not self._is_loaded:
-            self.network_table_name = self._load_network()
+            self._load_network()
 
     def _load_network(self) -> None:
         """Load the network file using the parent class import functionality."""
         if self._is_loaded:
             return
 
-        self.network_table_name = self._generate_table_name("v_input")
-
         # Import using the parent class method which handles metadata correctly
-        self.meta, self.network_table_name = super().import_input(
-            self.input_path, table_name=self.network_table_name
-        )
+        self.meta, self.network_table_name = super().import_input(self.input_path)
 
+        # Network loaded - use create_buffered_subset() to work with a subset for performance
         self._is_loaded = True
-        self._validate_network_schema()
 
-    def _validate_network_schema(self) -> None:
-        """Validate that the loaded network has required columns."""
+        # Validate required columns exist
         required_columns = {"edge_id", "source", "target", "geometry"}
 
         # Get actual column names from metadata
@@ -431,16 +561,3 @@ def _validate_network_schema(self) -> None:
         # Validate geometry column exists
         if not self.meta.geometry_column:
             raise ValueError("Network file must have a geometry column")
-
-    def _generate_table_name(self, prefix: str) -> str:
-        return f"{prefix}_{uuid.uuid4().hex[:8]}"
-
-    def _create_metadata_from_template(self, table_name: str) -> Metadata:
-        """Create metadata for tables with the same schema as the original network (fast path)."""
-        return Metadata(
-            geometry_column=self.meta.geometry_column,
-            geometry_type=self.meta.geometry_type,
-            crs=self.meta.crs,
-            columns=self.meta.columns,  # Reuse original columns since schema is identical
-            raw_meta={},
-        )
diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
index 6667735fc..5e9290d23 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
@@ -1,8 +1,9 @@
+import asyncio
 import logging
 from pathlib import Path
 from typing import Self
 
-from goatlib.routing.errors import RoutingError
+from goatlib.routing.errors import ParsingError, RoutingError, ServiceError
 from goatlib.routing.interfaces.routing_service import RoutingService
 from goatlib.routing.schemas.ab_routing import (
     ABRoutingRequest,
@@ -43,16 +44,48 @@ def __init__(self: Self, motis_client: MotisServiceClient) -> None:
         self.motis_client = motis_client
 
     async def route(self: Self, request: ABRoutingRequest) -> ABRoutingResponse:
+        """
+        Execute a routing request using the MOTIS plan API.
+        Args:
+            request: ABRoutingRequest containing origin, destination, modes, etc.
+        Returns:
+            ABRoutingResponse with routing results
+        Raises:
+            ParsingError: If request/response format is invalid
+            ServiceError: If network/service connection fails
+            RoutingError: For unexpected errors
+        """
+
         try:
+            # Translate our internal request to MOTIS format
             request_data = translate_to_motis_request(request)
+
+            # Make the network call to MOTIS
             motis_response = await self.motis_client.plan(request_data)
+
+            # Parse MOTIS response to our internal format
             response_data = parse_motis_response(motis_response)
 
             return response_data
 
+        except (asyncio.TimeoutError, ConnectionError) as e:
+            # Network-specific issues
+            logger.error(f"Network error while contacting MOTIS: {e}")
+            raise ServiceError("Failed to connect to the routing service") from e
+
+        except ParsingError as e:
+            # Request/response format issues - log and re-raise as-is
+            logger.warning(f"Parsing error in MOTIS routing: {e}")
+            raise
+
+        except ServiceError:
+            # Service errors from lower layers - re-raise as-is
+            raise
+
         except Exception as e:
-            logger.error(f"Failed to execute routing request via MOTIS: {e}")
-            raise RoutingError("Failed to process routing request via MOTIS") from e
+            # Unexpected errors - wrap in RoutingError
+            logger.error(f"Unexpected error during MOTIS routing: {e}")
+            raise RoutingError("An unexpected internal error occurred") from e
 
     async def get_transit_catchment_area(
         self: Self, request: TransitCatchmentAreaRequest
@@ -67,27 +100,40 @@ async def get_transit_catchment_area(
             TransitCatchmentAreaResponse with isochrone polygons
 
         Raises:
-            RoutingError: If the MOTIS service fails or returns invalid data
+            ParsingError: If request/response format is invalid
+            ServiceError: If network/service connection fails
+            RoutingError: For unexpected errors
         """
         try:
-            # Convert our request to MOTIS one-to-all parameters
+            # Translate our internal request to MOTIS one-to-all format
             request_data = translate_to_motis_one_to_all_request(request)
 
-            # Call MOTIS one-to-all API
+            # Make the network call to MOTIS
             motis_response = await self.motis_client.one_to_all(request_data)
 
-            # Parse response and convert to our format
+            # Parse MOTIS response to our internal format
             response_data = parse_motis_one_to_all_response(motis_response, request)
 
             return response_data
 
+        except (asyncio.TimeoutError, ConnectionError) as e:
+            # Network-specific issues
+            logger.error(f"Network error while contacting MOTIS one-to-all: {e}")
+            raise ServiceError("Failed to connect to the routing service") from e
+
+        except ParsingError as e:
+            # Request/response format issues - log and re-raise as-is
+            logger.warning(f"Parsing error in MOTIS catchment area: {e}")
+            raise
+
+        except ServiceError:
+            # Service errors from lower layers - re-raise as-is
+            raise
+
         except Exception as e:
-            logger.error(
-                f"Failed to execute transit catchment area request via MOTIS: {e}"
-            )
-            raise RoutingError(
-                "Failed to process transit catchment area request via MOTIS"
-            ) from e
+            # Unexpected errors - wrap in RoutingError
+            logger.error(f"Unexpected error during MOTIS catchment area request: {e}")
+            raise RoutingError("An unexpected internal error occurred") from e
 
 
 def create_motis_adapter(
@@ -101,6 +147,7 @@ def create_motis_adapter(
     Args:
         use_fixtures: Whether to use fixture data instead of real API calls
         fixture_path: Path to the directory containing MOTIS fixture data
+        base_url: Base URL for the MOTIS API
 
     Returns:
         Configured MotisPlanApiAdapter instance
diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_client.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_client.py
index b48223799..84655f0aa 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_client.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_client.py
@@ -6,6 +6,8 @@
 
 import httpx
 
+from goatlib.routing.errors import ParsingError, ServiceError
+
 logger = logging.getLogger(__name__)
 
 
@@ -81,7 +83,8 @@ async def plan(self: Self, motis_request: Dict[str, Any]) -> Dict[str, Any]:
             Raw MOTIS response data
 
         Raises:
-            RuntimeError: If the MOTIS service is unavailable or returns an error
+            ServiceError: If the MOTIS service is unavailable or returns an error
+            ParsingError: If the response format is invalid
         """
         if self.use_fixtures:
             return self._load_fixture_response()
@@ -99,7 +102,8 @@ async def one_to_all(self: Self, motis_request: Dict[str, Any]) -> Dict[str, Any
             Raw MOTIS one-to-all response data
 
         Raises:
-            RuntimeError: If the MOTIS service is unavailable or returns an error
+            ServiceError: If the MOTIS service is unavailable or returns an error
+            ParsingError: If the response format is invalid
         """
         # For now, one-to-all only supports real API calls, not fixtures
         return await self._make_one_to_all_api_request(motis_request)
@@ -127,16 +131,18 @@ async def _make_plan_api_request(
             else:
                 log_msg = f"An unexpected request error occurred: {e}"
             logger.error(log_msg)
-            raise RuntimeError("MOTIS service request failed to complete.") from e
+            raise ServiceError("MOTIS service request failed to complete.") from e
 
         except json.JSONDecodeError as e:
             logger.error(f"Failed to parse JSON response from MOTIS service: {e}")
-            raise RuntimeError("Invalid response format from MOTIS service.") from e
+            raise ParsingError("Invalid response format from MOTIS service.") from e
 
     async def _make_one_to_all_api_request(
         self: Self, api_params: Dict[str, Any]
     ) -> Dict[str, Any]:
-        logger.info(f"Making async MOTIS one-to-all request to {self.one_to_all_endpoint}")
+        logger.info(
+            f"Making async MOTIS one-to-all request to {self.one_to_all_endpoint}"
+        )
         try:
             response = await self._http_client.get(
                 self.one_to_all_endpoint,
@@ -148,7 +154,9 @@ async def _make_one_to_all_api_request(
 
         except httpx.RequestError as e:
             if isinstance(e, httpx.TimeoutException):
-                log_msg = f"Request to MOTIS one-to-all service timed out at {e.request.url}"
+                log_msg = (
+                    f"Request to MOTIS one-to-all service timed out at {e.request.url}"
+                )
             if isinstance(e, httpx.HTTPStatusError):
                 log_msg = f"MOTIS one-to-all service returned error {e.response.status_code} for request to {e.request.url}"
             if isinstance(e, httpx.ConnectionError):
@@ -156,11 +164,17 @@ async def _make_one_to_all_api_request(
             else:
                 log_msg = f"An unexpected request error occurred: {e}"
             logger.error(log_msg)
-            raise RuntimeError("MOTIS one-to-all service request failed to complete.") from e
+            raise ServiceError(
+                "MOTIS one-to-all service request failed to complete."
+            ) from e
 
         except json.JSONDecodeError as e:
-            logger.error(f"Failed to parse JSON response from MOTIS one-to-all service: {e}")
-            raise RuntimeError("Invalid response format from MOTIS one-to-all service.") from e
+            logger.error(
+                f"Failed to parse JSON response from MOTIS one-to-all service: {e}"
+            )
+            raise ParsingError(
+                "Invalid response format from MOTIS one-to-all service."
+            ) from e
 
     async def close(self: Self) -> None:
         """Closes the underlying HTTP client."""
diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
index d8b274790..b9f5716ab 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
@@ -11,7 +11,12 @@
     ABRoutingRequest,
     ABRoutingResponse,
 )
-from goatlib.routing.schemas.base import AccessEgressMode, Coordinates, Mode
+from goatlib.routing.schemas.base import (
+    AccessEgressMode,
+    Coordinates,
+    Mode,
+    RoutingProvider,
+)
 from goatlib.routing.schemas.catchment_area_transit import (
     CatchmentAreaPolygon,
     TransitCatchmentAreaRequest,
@@ -83,6 +88,14 @@ def _extract_place_data(place: Dict[str, Any]) -> Dict[str, Any]:
 
 def translate_to_motis_request(request: ABRoutingRequest) -> Dict[str, Any]:
     """Convert ABRoutingRequest to MOTIS v5/plan GET API parameters."""
+    if not request:
+        raise ParsingError("Routing request cannot be None or empty")
+
+    if request.provider != RoutingProvider.motis:
+        raise ParsingError(
+            f"MotisPlanApiAdapter cannot handle requests for provider {request.provider}"
+        )
+
     params = motis_settings.request_params
     defaults = motis_settings.defaults
 
diff --git a/packages/python/goatlib/src/goatlib/routing/errors.py b/packages/python/goatlib/src/goatlib/routing/errors.py
index e567438f7..bb46265ff 100644
--- a/packages/python/goatlib/src/goatlib/routing/errors.py
+++ b/packages/python/goatlib/src/goatlib/routing/errors.py
@@ -8,3 +8,9 @@ class ParsingError(RoutingError):
     """Raised when an API response cannot be parsed correctly."""
 
     pass
+
+
+class ServiceError(RoutingError):
+    """Raised when the routing service is unavailable or returns an error."""
+
+    pass
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py b/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
index c117fe53a..54957f3aa 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
@@ -8,7 +8,7 @@
 )
 
 
-class CatchmentSchema(BaseModel):
+class Catchment(BaseModel):
     """Schema for catchment area requests."""
 
     starting_points: List[Coordinates] = Field(
@@ -23,7 +23,6 @@ class CatchmentSchema(BaseModel):
         title="Cutoffs",
         description="List of cost thresholds for catchment area calculation (time in minutes or distance in meters).",
         min_length=1,
-        max_length=10,
     )
 
     type: CatchmentAreaType = Field(
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
index f07564062..830e1a019 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
@@ -10,7 +10,7 @@
 )
 
 
-class CatchmentAreaStartingPointsPT(BaseModel):
+class TransitCatchmentAreaStartingPoints(BaseModel):
     """Starting points for transit catchment areas (single point only)."""
 
     lat: List[float] = Field(
@@ -34,7 +34,7 @@ def validate_single_point(self) -> Self:
         return self
 
 
-class TravelTimeCost(BaseModel):
+class TransitCatchmentAreaTravelTimeCost(BaseModel):
     """Travel time configuration with cutoffs for transit analysis."""
 
     max_traveltime: int = Field(
@@ -164,7 +164,7 @@ class TransitRoutingSettings(BaseModel):
 class TransitCatchmentAreaRequest(BaseModel):
     """Unified request model for transit catchment area calculation."""
 
-    starting_points: CatchmentAreaStartingPointsPT = Field(
+    starting_points: TransitCatchmentAreaStartingPoints = Field(
         ...,
         title="Starting Points",
         description="Starting point for catchment area calculation (single point only).",
@@ -175,7 +175,7 @@ class TransitCatchmentAreaRequest(BaseModel):
         description="List of transit modes to include in the calculation.",
         min_length=1,
     )
-    travel_cost: TravelTimeCost = Field(
+    travel_cost: TransitCatchmentAreaTravelTimeCost = Field(
         ...,
         title="Travel Cost Configuration",
         description="Travel time and cutoff configuration.",
@@ -208,12 +208,7 @@ def max_transfers(self) -> int:
         return self.routing_settings.max_transfers
 
 
-# Backward compatibility aliases
-TransitCatchmentAreaStartingPoints = CatchmentAreaStartingPointsPT
-TransitCatchmentAreaTravelTimeCost = TravelTimeCost
-
-
-"""Response schemas."""
+# ------------------------ Response Schemas ----------------------
 
 
 class CatchmentAreaPolygon(BaseModel):
@@ -265,7 +260,7 @@ class TransitCatchmentAreaResponse(BaseModel):
     )
 
 
-"""Example requests."""
+# ------------------------ Example Requests ----------------------
 
 
 request_examples_transit_catchment_area = {
diff --git a/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py b/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py
index 4dd629743..23adacbc3 100644
--- a/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py
+++ b/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py
@@ -1,5 +1,4 @@
 import tracemalloc
-from pathlib import Path
 from typing import Any, Dict
 
 import psutil
diff --git a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py b/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py
index fcac9a411..29b1a210a 100644
--- a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py
+++ b/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py
@@ -6,7 +6,7 @@
 from goatlib.routing.schemas.catchment_area_transit import (
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaStartingPoints,
-    TravelTimeCost,
+    TransitCatchmentAreaTravelTimeCost,
 )
 
 from .conftest import BenchmarkMetrics, save_benchmark_results
@@ -75,7 +75,7 @@ async def test_motis_one_to_all_performance_benchmark():
             ],
             access_mode=AccessEgressMode.walk,
             egress_mode=AccessEgressMode.walk,
-            travel_cost=TravelTimeCost(
+            travel_cost=TransitCatchmentAreaTravelTimeCost(
                 max_traveltime=45,
                 cutoffs=[15, 30, 45],  # Multiple cutoffs for larger response
             ),
@@ -209,7 +209,7 @@ async def test_motis_one_to_all_minimal_benchmark():
             transit_modes=[CatchmentAreaRoutingModePT.subway],
             access_mode=AccessEgressMode.walk,
             egress_mode=AccessEgressMode.walk,
-            travel_cost=TravelTimeCost(
+            travel_cost=TransitCatchmentAreaTravelTimeCost(
                 max_traveltime=15,
                 cutoffs=[15],
             ),
diff --git a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_plausibility.py b/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_plausibility.py
index ae3e4b168..3dbeacdc8 100644
--- a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_plausibility.py
+++ b/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_plausibility.py
@@ -13,8 +13,8 @@
 from goatlib.routing.schemas.catchment_area_transit import (
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaStartingPoints,
+    TransitCatchmentAreaTravelTimeCost,
     TransitRoutingSettings,
-    TravelTimeCost,
 )
 
 logger = logging.getLogger(__name__)
@@ -139,7 +139,7 @@ async def run_comprehensive_test(self) -> Dict[str, Any]:
                 ],
                 access_mode=AccessEgressMode.walk,
                 egress_mode=AccessEgressMode.walk,
-                travel_cost=TravelTimeCost(
+                travel_cost=TransitCatchmentAreaTravelTimeCost(
                     max_traveltime=30,
                     cutoffs=[10, 20, 30],
                 ),
@@ -258,7 +258,7 @@ def sample_request():
         ],
         access_mode=AccessEgressMode.walk,
         egress_mode=AccessEgressMode.walk,
-        travel_cost=TravelTimeCost(
+        travel_cost=TransitCatchmentAreaTravelTimeCost(
             max_traveltime=30,
             cutoffs=[10, 20, 30],
         ),
@@ -278,7 +278,7 @@ async def test_motis_one_to_all_raw_response_validation(plausibility_tester):
                 lon=[11.5820],
             ),
             transit_modes=[CatchmentAreaRoutingModePT.bus],
-            travel_cost=TravelTimeCost(
+            travel_cost=TransitCatchmentAreaTravelTimeCost(
                 max_traveltime=20,
                 cutoffs=[10, 20],
             ),
diff --git a/packages/python/goatlib/tests/integration/network/conftest.py b/packages/python/goatlib/tests/integration/network/conftest.py
deleted file mode 100644
index bbffcf7f4..000000000
--- a/packages/python/goatlib/tests/integration/network/conftest.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from pathlib import Path
-
-import pytest
-from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
-
-
-@pytest.fixture
-def processor(network_file: Path) -> InMemoryNetworkProcessor:
-    """A pytest fixture that yields a processor within a context manager."""
-    with InMemoryNetworkProcessor(str(network_file)) as proc:
-        yield proc
-    # Cleanup is handled automatically as the 'with' block exits
diff --git a/packages/python/goatlib/tests/integration/network/test_edge_splitting.py b/packages/python/goatlib/tests/integration/network/test_edge_splitting.py
deleted file mode 100644
index 0d604f132..000000000
--- a/packages/python/goatlib/tests/integration/network/test_edge_splitting.py
+++ /dev/null
@@ -1,162 +0,0 @@
-import logging
-
-from goatlib.analysis.network.network_processor import (
-    InMemoryNetworkProcessor,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def test_split_output_and_properties(processor: InMemoryNetworkProcessor) -> None:
-    """
-    Tests the `split_info` dictionary for correctness and reasonable values.
-    This combines 'test_basic_edge_split' and 'test_split_info_coordinates'.
-    """
-    _, split_meta = processor.split_edge_at_point(latitude=48.13, longitude=11.58)
-
-    # Extract split info from metadata
-    split_info = split_meta.raw_meta["split_operation"]
-
-    # Verify structure and existence of keys
-    assert split_info["artificial_node_id"] is not None
-    assert split_info["original_edge_split"] is not None
-    assert "new_node_coords" in split_info
-
-    # Verify values and types
-    assert 0.0 <= split_info["split_fraction"] <= 1.0
-    coords = split_info["new_node_coords"]
-    assert isinstance(coords["lon"], float)
-    assert isinstance(coords["lat"], float)
-
-    # Verify reasonable coordinate range
-    assert 11.0 < coords["lon"] < 12.0
-    assert 48.0 < coords["lat"] < 49.0
-
-
-def test_split_topology_and_invariance(processor: InMemoryNetworkProcessor) -> None:
-    """
-    Comprehensive test for split operation correctness:
-    - Network metrics are preserved (length, edge count +1)
-    - Topology is correct (original edge removed, 2 new edges added)
-    - New edges have correct naming and connectivity
-    """
-    original_stats = processor.get_network_stats()
-    original_table_name = processor.network_table_name
-
-    split_table, split_meta = processor.split_edge_at_point(
-        latitude=48.13, longitude=11.58
-    )
-
-    # Extract split info from metadata
-    split_info = split_meta.raw_meta["split_operation"]
-    split_stats = processor.get_network_stats(split_table)
-    original_edge_id = split_info["original_edge_split"]
-    new_node_id = split_info["artificial_node_id"]
-
-    # 1. Test Network Metrics Invariance
-    assert split_stats["edge_count"] == original_stats["edge_count"] + 1
-    assert abs(split_stats["total_length_m"] - original_stats["total_length_m"]) < 1.0
-    assert split_stats["avg_length_m"] < original_stats["avg_length_m"]
-
-    # 2. Test Original Edge Removal
-    original_edge_count = processor.con.execute(
-        f"SELECT COUNT(*) FROM {split_table} WHERE edge_id = '{original_edge_id}'"
-    ).fetchone()[0]
-    assert original_edge_count == 0
-
-    # 3. Test New Edge Creation and Naming
-    split_edges = processor.con.execute(f"""
-        SELECT edge_id, source, target FROM {split_table}
-        WHERE edge_id LIKE '{original_edge_id}_part_%' ORDER BY edge_id
-    """).fetchall()
-
-    assert len(split_edges) == 2
-    edge_a, edge_b = split_edges
-
-    # Check naming pattern
-    assert edge_a[0] == f"{original_edge_id}_part_a"
-    assert edge_b[0] == f"{original_edge_id}_part_b"
-
-    # Check connectivity topology
-    assert edge_a[2] == new_node_id  # target of part_a
-    assert edge_b[1] == new_node_id  # source of part_b
-
-    # 4. Test Edge Set Differences (verify exactly what changed)
-    removed_edges = processor.con.execute(f"""
-        SELECT edge_id FROM {original_table_name}
-        EXCEPT SELECT edge_id FROM {split_table}
-    """).fetchall()
-    assert len(removed_edges) == 1
-    assert str(removed_edges[0][0]) == str(original_edge_id)
-
-    added_edges = processor.con.execute(f"""
-        SELECT edge_id FROM {split_table}
-        EXCEPT SELECT edge_id FROM {original_table_name}
-    """).fetchall()
-    added_edge_ids = {row[0] for row in added_edges}
-    assert len(added_edge_ids) == 2
-    assert f"{original_edge_id}_part_a" in added_edge_ids
-    assert f"{original_edge_id}_part_b" in added_edge_ids
-
-
-def test_comprehensive_workflow(processor: InMemoryNetworkProcessor) -> None:
-    """
-    Tests a realistic, chained workflow: filter -> split -> filter again.
-    This confirms that the non-destructive design works as intended.
-    """
-    original_stats = processor.get_network_stats()
-    original_table = processor.network_table_name
-
-    # Step 1: Filter
-    filtered_table = processor.apply_sql_query(
-        f"SELECT * FROM {original_table} WHERE length_m > 50"
-    )
-    filtered_stats = processor.get_network_stats(filtered_table)
-    assert filtered_stats["edge_count"] < original_stats["edge_count"]
-
-    # Step 2: Split on the filtered network
-    split_table, split_meta = processor.split_edge_at_point(
-        latitude=48.13, longitude=11.58, base_table=filtered_table
-    )
-    split_stats = processor.get_network_stats(split_table)
-    assert split_stats["edge_count"] == filtered_stats["edge_count"] + 1
-
-    # Step 3: Apply another operation on the split network
-    final_table = processor.apply_sql_query(
-        f"SELECT * FROM  {split_table} WHERE cost > 10",
-    )
-    final_stats = processor.get_network_stats(final_table)
-    assert final_stats["edge_count"] <= split_stats["edge_count"]
-
-
-def test_split_is_non_destructive(processor: InMemoryNetworkProcessor) -> None:
-    """
-    Tests that the original network table remains unchanged after a split operation.
-    """
-    original_stats = processor.get_network_stats()
-    original_table_name = processor.network_table_name
-
-    # Perform the split operation
-    split_table, split_meta = processor.split_edge_at_point(
-        latitude=48.13, longitude=11.58
-    )
-
-    # Verify that the original table was not altered
-    post_split_stats = processor.get_network_stats(original_table_name)
-    import pytest
-
-    # Use pytest.approx for floating-point comparisons to handle precision differences
-    assert post_split_stats["edge_count"] == pytest.approx(original_stats["edge_count"])
-    assert post_split_stats["total_length_m"] == pytest.approx(
-        original_stats["total_length_m"]
-    )
-    assert post_split_stats["avg_length_m"] == pytest.approx(
-        original_stats["avg_length_m"]
-    )
-    assert post_split_stats["min_length_m"] == pytest.approx(
-        original_stats["min_length_m"]
-    )
-    assert post_split_stats["max_length_m"] == pytest.approx(
-        original_stats["max_length_m"]
-    )
-    assert post_split_stats == original_stats
diff --git a/packages/python/goatlib/tests/integration/network/test_interpolation.py b/packages/python/goatlib/tests/integration/network/test_interpolation.py
deleted file mode 100644
index cd7d993bd..000000000
--- a/packages/python/goatlib/tests/integration/network/test_interpolation.py
+++ /dev/null
@@ -1,130 +0,0 @@
-import logging
-
-from goatlib.analysis.network.network_processor import (
-    InMemoryNetworkProcessor,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def test_interpolate_long_edges(processor: InMemoryNetworkProcessor) -> None:
-    """Test edge interpolation functionality."""
-    # Get original network stats
-    original_stats = processor.get_network_stats()
-
-    # Find a reasonable threshold - use 75th percentile of edge lengths
-    edge_lengths = processor.con.execute(f"""
-        SELECT length_m FROM {processor.network_table_name} 
-        ORDER BY length_m DESC
-    """).fetchall()
-
-    if len(edge_lengths) < 4:
-        # Skip test if network is too small
-        return
-
-    # Use a threshold that will catch some but not all edges
-    max_length = edge_lengths[len(edge_lengths) // 4][0]  # 75th percentile
-    interpolation_distance = max_length / 3  # Create multiple segments
-
-    # Perform interpolation
-    interpolated_table, interpolated_meta = processor.interpolate_long_edges(
-        max_edge_length=max_length, interpolation_distance=interpolation_distance
-    )
-
-    # Extract interpolation info from metadata
-    info = interpolated_meta.raw_meta["interpolation_operation"]
-
-    # Verify interpolation info
-    assert info["original_edge_count"] == original_stats["edge_count"]
-    assert info["max_edge_length_threshold"] == max_length
-    assert info["interpolation_distance"] == interpolation_distance
-    assert (
-        info["final_edge_count"] >= info["original_edge_count"]
-    )  # Should have more edges
-    assert info["processing_time_seconds"] > 0
-
-    # Verify the interpolated network has valid stats
-    interpolated_stats = processor.get_network_stats(interpolated_table)
-    assert interpolated_stats["edge_count"] == info["final_edge_count"]
-    assert interpolated_stats["edge_count"] > 0
-
-    # Check that no edge in the interpolated network exceeds the threshold
-    long_edges_count = processor.con.execute(f"""
-        SELECT COUNT(*) FROM {interpolated_table} WHERE length_m > {max_length}
-    """).fetchone()[0]
-    assert (
-        long_edges_count == 0
-    ), f"Found {long_edges_count} edges still longer than {max_length}m"
-
-    # Verify intermediate nodes were created
-    if info["new_intermediate_nodes"] > 0:
-        intermediate_nodes = processor.con.execute(f"""
-            SELECT COUNT(DISTINCT node_id) FROM (
-                SELECT source as node_id FROM {interpolated_table} WHERE source LIKE 'interp_%'
-                UNION 
-                SELECT target as node_id FROM {interpolated_table} WHERE target LIKE 'interp_%'
-            )
-        """).fetchone()[0]
-        assert intermediate_nodes > 0, "Should have created intermediate nodes"
-
-    # Verify total length is preserved (approximately)
-    original_total_length = original_stats["total_length_m"]
-    interpolated_total_length = interpolated_stats["total_length_m"]
-    length_diff = abs(original_total_length - interpolated_total_length)
-    assert (
-        length_diff / original_total_length < 0.01
-    ), f"Total length changed too much: {length_diff}m"
-
-    logger.info("Interpolation test completed:")
-    logger.info(f"  Original edges: {info['original_edge_count']}")
-    logger.info(f"  Long edges processed: {info['long_edges_processed']}")
-    logger.info(f"  Final edges: {info['final_edge_count']}")
-    logger.info(f"  New intermediate nodes: {info['new_intermediate_nodes']}")
-    logger.info(f"  Max edge length threshold: {max_length:.1f}m")
-    logger.info(f"  Processing time: {info['processing_time_seconds']:.2f}s")
-
-
-def test_interpolate_with_custom_distance(processor: InMemoryNetworkProcessor) -> None:
-    """Test edge interpolation with custom interpolation distance."""
-    max_length = 200.0
-    interpolation_distance = 50.0
-
-    interpolated_table, interpolated_meta = processor.interpolate_long_edges(
-        max_edge_length=max_length, interpolation_distance=interpolation_distance
-    )
-
-    # Extract interpolation info from metadata
-    info = interpolated_meta.raw_meta["interpolation_operation"]
-
-    # Verify configuration was used
-    assert info["max_edge_length_threshold"] == max_length
-    assert info["interpolation_distance"] == interpolation_distance
-
-    # Check that edges are properly segmented
-    max_edge_in_result = processor.con.execute(f"""
-        SELECT MAX(length_m) FROM {interpolated_table}
-    """).fetchone()[0]
-
-    # Should be approximately equal to interpolation_distance (or less)
-    assert (
-        max_edge_in_result <= max_length
-    ), f"Max edge length {max_edge_in_result} exceeds threshold {max_length}"
-
-
-def test_interpolate_default_distance(processor: InMemoryNetworkProcessor) -> None:
-    """Test edge interpolation with default interpolation distance."""
-    max_length = 100.0
-
-    interpolated_table, interpolated_meta = processor.interpolate_long_edges(
-        max_edge_length=max_length
-    )
-
-    # Extract interpolation info from metadata
-    info = interpolated_meta.raw_meta["interpolation_operation"]
-
-    # Verify default interpolation distance was used (half of max_length)
-    assert info["interpolation_distance"] == max_length / 2
-    assert info["max_edge_length_threshold"] == max_length
-
-    # Check that interpolation worked
-    assert info["final_edge_count"] >= info["original_edge_count"]
diff --git a/packages/python/goatlib/tests/integration/network/test_network_operations.py b/packages/python/goatlib/tests/integration/network/test_network_operations.py
deleted file mode 100644
index 3f000c4a6..000000000
--- a/packages/python/goatlib/tests/integration/network/test_network_operations.py
+++ /dev/null
@@ -1,162 +0,0 @@
-import logging
-from pathlib import Path
-
-from goatlib.analysis.network.network_processor import (
-    InMemoryNetworkProcessor,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def test_network_loading_and_stats(processor: InMemoryNetworkProcessor) -> None:
-    """Test that the network loads correctly with valid stats."""
-    stats = processor.get_network_stats()
-    assert stats["edge_count"] > 0
-    assert stats["min_length_m"] <= stats["avg_length_m"] <= stats["max_length_m"]
-
-
-def test_operation_chaining_with_correctness_checks(
-    processor: InMemoryNetworkProcessor,
-) -> None:
-    """Tests chaining non-destructive operations and verifies intermediate results."""
-    base_table_name = processor.network_table_name
-    filtered = processor.apply_sql_query(
-        f"SELECT * FROM {base_table_name} WHERE length_m > 150"
-    )
-
-    # 2. Use the result of the previous step ('filtered') directly in the next query
-    #    The 'base_table' argument is no longer needed.
-    transformed = processor.apply_sql_query(
-        f"SELECT *, length_m * 1.1 as adjusted_length FROM {filtered}"
-    )
-
-    # 3. Use the result of the previous step ('transformed') directly in the next query
-    summary = processor.apply_sql_query(
-        f"SELECT COUNT(*) as total_edges FROM {transformed}"
-    )
-
-    filtered_stats = processor.get_network_stats(filtered)
-    transformed_stats = processor.get_network_stats(transformed)
-    summary_count = processor.con.execute(
-        f"SELECT total_edges FROM {summary}"
-    ).fetchone()[0]
-
-    # Assert that intermediate tables still exist and are correct
-    assert filtered_stats["edge_count"] > 0
-    assert transformed_stats["edge_count"] == filtered_stats["edge_count"]
-    assert summary_count == transformed_stats["edge_count"]
-
-
-def test_get_available_tables(processor: InMemoryNetworkProcessor) -> None:
-    """Test that get_available_tables returns the correct list of tables."""
-    # Initially, only the main network table should be present
-    tables = processor.get_available_tables()
-    assert processor.network_table_name in tables
-    logger.info(f"Available tables: {tables}")
-    # Create an intermediate table
-    intermediate_table = processor.apply_sql_query(
-        f"SELECT * FROM {processor.network_table_name} WHERE length_m > 100"
-    )
-
-    # Now both tables should be present
-    tables_after = processor.get_available_tables()
-    assert processor.network_table_name in tables_after
-    assert intermediate_table in tables_after
-    logger.info(f"Available tables: {tables_after}")
-
-
-def test_context_manager_cleanup(network_file: Path) -> None:
-    """Test that context manager properly handles cleanup when exiting the block."""
-    # Use the context manager to create a processor
-    table_names_inside = None
-    network_table_name = None
-
-    with InMemoryNetworkProcessor(str(network_file)) as processor:
-        # Create some intermediate tables
-        network_table_name = processor.network_table_name
-        table1 = processor.apply_sql_query(
-            f"SELECT * FROM {network_table_name} WHERE length_m > 100"
-        )
-        table2 = processor.apply_sql_query(
-            f"SELECT * FROM {network_table_name} WHERE cost > 50"
-        )
-
-        # Verify they exist while inside the context
-        table_names_inside = {
-            t[0]
-            for t in processor.con.execute(
-                "SELECT table_name FROM information_schema.tables"
-            ).fetchall()
-        }
-        assert table1 in table_names_inside
-        assert table2 in table_names_inside
-        assert network_table_name in table_names_inside
-
-    # After exiting the context manager, the processor's connection should be closed
-    # and cleanup should have been performed automatically
-    assert table_names_inside is not None
-    assert (
-        len(table_names_inside) >= 3
-    )  # At minimum: network table + 2 intermediate tables
-
-
-def test_save_to_file(processor: InMemoryNetworkProcessor, tmp_path: str) -> None:
-    """Test saving a table to a parquet file."""
-    output_file = Path("./network_output.parquet")
-    processor.save_table_to_file(processor.network_table_name, str(output_file))
-
-    # Verify the file was created
-    assert output_file.exists()
-    assert output_file.stat().st_size > 0
-
-
-def test_save_to_tmp(processor: InMemoryNetworkProcessor) -> None:
-    """Test saving a table to a temporary parquet file."""
-    tmp_file_path = processor.save_table_to_tmp(processor.network_table_name)
-
-    # Verify the file was created
-    from pathlib import Path
-
-    tmp_file = Path(tmp_file_path)
-    assert tmp_file.exists()
-    assert tmp_file.stat().st_size > 0
-
-
-def test_concurrent_access(network_file: str) -> None:
-    """Test that multiple processors can be created and used concurrently safely."""
-    import concurrent.futures
-
-    from goatlib.analysis.network.network_processor import (
-        InMemoryNetworkProcessor,
-    )
-
-    def create_processor_and_get_stats() -> dict:
-        # Each thread gets its own processor instance with its own connection
-        with InMemoryNetworkProcessor(str(network_file)) as proc:
-            return proc.get_network_stats()
-
-    # Use a smaller number of workers to avoid resource exhaustion
-    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
-        futures = [executor.submit(create_processor_and_get_stats) for _ in range(3)]
-        results = [f.result() for f in concurrent.futures.as_completed(futures)]
-
-    # Verify all processors got consistent results
-    for stats in results:
-        assert stats["edge_count"] > 0
-
-    # All results should be identical since they're loading the same file
-    edge_counts = [stats["edge_count"] for stats in results]
-    assert (
-        len(set(edge_counts)) == 1
-    ), "All processors should report the same edge count"
-
-
-def test_network_is_wkb_format(processor: InMemoryNetworkProcessor) -> None:
-    """Test that the network geometries are in WKB format."""
-    sample_geometry = processor.con.execute(
-        f"SELECT geometry FROM {processor.network_table_name} LIMIT 1"
-    ).fetchone()[0]
-
-    assert isinstance(
-        sample_geometry, bytes
-    ), f"Geometry should be in WKB format (bytes), got {type(sample_geometry)}"
diff --git a/packages/python/goatlib/tests/integration/network/test_network_preprocessing.py b/packages/python/goatlib/tests/integration/network/test_network_preprocessing.py
new file mode 100644
index 000000000..628a250af
--- /dev/null
+++ b/packages/python/goatlib/tests/integration/network/test_network_preprocessing.py
@@ -0,0 +1,221 @@
+import logging
+from pathlib import Path
+
+import pytest
+from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
+
+logger = logging.getLogger(__name__)
+
+
+def test_buffered_subset_creation(network_file: Path):
+    """Test creating a spatial subset of network within a buffer."""
+    # Munich city center coordinates
+    lat, lon = 48.1351, 11.5820
+    buffer_radius = 3000  # 3km
+
+    with InMemoryNetworkProcessor(str(network_file)) as processor:
+        # Create buffered subset
+        subset_table = processor.create_buffered_subset(
+            latitude=lat, longitude=lon, buffer_radius=buffer_radius
+        )
+
+        # Verify subset table was created
+        available_tables = processor.get_available_tables()
+        assert subset_table in available_tables
+
+        # Get statistics
+        subset_meta = processor.get_subset_metadata(
+            subset_table=subset_table,
+            latitude=lat,
+            longitude=lon,
+            buffer_radius=buffer_radius,
+        )
+
+        # Verify buffer operation metadata
+        assert "buffer_operation" in subset_meta.raw_meta
+        buffer_info = subset_meta.raw_meta["buffer_operation"]
+        assert buffer_info["operation"] == "spatial_buffer"
+        assert buffer_info["buffer_radius_m"] == buffer_radius
+        assert buffer_info["subset_edge_count"] > 0
+        assert buffer_info["subset_edge_count"] < buffer_info["original_edge_count"]
+        assert 0 < buffer_info["reduction_ratio"] < 1.0
+
+        # Verify subset is smaller than original
+        original_stats = processor.get_network_stats()
+        subset_stats = processor.get_network_stats(subset_table)
+        assert subset_stats["edge_count"] < original_stats["edge_count"]
+
+
+def test_edge_splitting_at_point(network_file: Path):
+    """Test splitting closest edge at a given point."""
+    # Point near Munich center
+    lat, lon = 48.1370, 11.5760
+
+    with InMemoryNetworkProcessor(str(network_file)) as processor:
+        # First create a buffered subset for faster testing
+        subset_table = processor.create_buffered_subset(
+            latitude=lat, longitude=lon, buffer_radius=2000
+        )
+
+        # Split edge at the point
+        split_table, split_meta = processor.split_edge_at_point(
+            latitude=lat,
+            longitude=lon,
+            base_table=subset_table,
+            max_search_radius=200,
+        )
+
+        # Verify split table was created
+        available_tables = processor.get_available_tables()
+        assert split_table in available_tables
+
+        # Verify split operation metadata
+        assert "split_operation" in split_meta.raw_meta
+        split_info = split_meta.raw_meta["split_operation"]
+        assert split_info["operation"] == "edge_split"
+        assert split_info["method"] == "bbox_optimization"
+        assert "artificial_node_id" in split_info
+        assert "original_edge_split" in split_info
+        assert 0.0 <= split_info["split_fraction"] <= 1.0
+        assert split_info["distance_to_edge"] <= 200
+
+        # Verify new node coordinates are close to input point
+        new_node = split_info["new_node_coords"]
+        assert abs(new_node["lat"] - lat) < 0.01  # Within ~1km
+        assert abs(new_node["lon"] - lon) < 0.01
+
+        # Verify split table has more edges (original edge replaced with 2 parts)
+        subset_stats = processor.get_network_stats(subset_table)
+        split_stats = processor.get_network_stats(split_table)
+        assert split_stats["edge_count"] == subset_stats["edge_count"] + 1
+
+
+def test_complete_preprocessing_workflow(network_file: Path):
+    """Test the complete workflow: buffer → split → interpolate."""
+    # Origin point
+    origin_lat, origin_lon = 48.1351, 11.5820
+    buffer_radius = 5000  # 5km
+
+    with InMemoryNetworkProcessor(str(network_file)) as processor:
+        # Step 1: Create buffered subset
+        subset_table = processor.create_buffered_subset(
+            latitude=origin_lat, longitude=origin_lon, buffer_radius=buffer_radius
+        )
+
+        subset_stats = processor.get_network_stats(subset_table)
+        assert subset_stats["edge_count"] > 0
+        print(f"\n📊 Subset contains {subset_stats['edge_count']} edges")
+
+        # Step 2: Split edge at origin point
+        split_table, split_meta = processor.split_edge_at_point(
+            latitude=origin_lat,
+            longitude=origin_lon,
+            base_table=subset_table,
+            max_search_radius=200,
+        )
+
+        origin_node_id = split_meta.raw_meta["split_operation"]["artificial_node_id"]
+        assert origin_node_id is not None
+        assert origin_node_id.startswith("split_node_")
+        print(f"🎯 Origin node created: {origin_node_id}")
+
+        split_stats = processor.get_network_stats(split_table)
+        print(f"📈 Split network has {split_stats['edge_count']} edges")
+
+        # Verify edges are connected to the artificial node
+        connected_edges = processor.con.execute(
+            f"""
+            SELECT COUNT(*)
+            FROM {split_table}
+            WHERE source = '{origin_node_id}' OR target = '{origin_node_id}'
+            """
+        ).fetchone()[0]
+        assert connected_edges > 0
+        print(f"🔗 {connected_edges} edges connected to origin node")
+
+
+def test_edge_interpolation(network_file: Path):
+    """Test interpolation of long edges into smaller segments."""
+    max_edge_length = 100.0  # Split edges longer than 100m
+
+    with InMemoryNetworkProcessor(str(network_file)) as processor:
+        # Get original stats
+        original_stats = processor.get_network_stats()
+        print(f"\n📊 Original network: {original_stats['edge_count']} edges")
+        print(f"   Max edge length: {original_stats['max_length_m']:.2f}m")
+
+        # Count long edges
+        long_edges = processor.con.execute(
+            f"""
+            SELECT COUNT(*)
+            FROM {processor.network_table_name}
+            WHERE length_m > {max_edge_length}
+            """
+        ).fetchone()[0]
+        print(f"   Long edges (>{max_edge_length}m): {long_edges}")
+
+        # Interpolate long edges
+        interpolated_table, interp_meta = processor.interpolate_long_edges(
+            max_edge_length=max_edge_length
+        )
+
+        # Verify interpolation metadata
+        assert "interpolation_operation" in interp_meta.raw_meta
+        interp_info = interp_meta.raw_meta["interpolation_operation"]
+        assert interp_info["max_edge_length_threshold"] == max_edge_length
+        assert interp_info["long_edges_processed"] == long_edges
+        assert interp_info["final_edge_count"] > interp_info["original_edge_count"]
+        assert interp_info["edges_added"] > 0
+        assert interp_info["new_intermediate_nodes"] > 0
+
+        print(f"✂️  Interpolated network: {interp_info['final_edge_count']} edges")
+        print(f"   Edges added: {interp_info['edges_added']}")
+        print(f"   New intermediate nodes: {interp_info['new_intermediate_nodes']}")
+        print(f"   Processing time: {interp_info['processing_time_seconds']:.3f}s")
+
+        # Verify no edge exceeds max length
+        longest_edge = processor.con.execute(
+            f"""
+            SELECT MAX(length_m)
+            FROM {interpolated_table}
+            """
+        ).fetchone()[0]
+        assert longest_edge <= max_edge_length * 1.01  # Allow 1% tolerance
+        print(f"   New max edge length: {longest_edge:.2f}m ✅")
+
+
+@pytest.mark.parametrize(
+    "lat,lon,buffer_radius",
+    [
+        (48.1351, 11.5820, 1000),  # Small buffer
+        (48.1351, 11.5820, 5000),  # Medium buffer
+        (48.1351, 11.5820, 10000),  # Large buffer
+    ],
+)
+def test_buffer_radius_variations(
+    network_file: Path, lat: float, lon: float, buffer_radius: float
+):
+    """Test that larger buffers result in more edges."""
+    with InMemoryNetworkProcessor(str(network_file)) as processor:
+        subset_table = processor.create_buffered_subset(
+            latitude=lat, longitude=lon, buffer_radius=buffer_radius
+        )
+
+        stats = processor.get_network_stats(subset_table)
+        print(f"\n📏 Buffer {buffer_radius}m: {stats['edge_count']} edges")
+
+        # Verify proportional relationship exists
+        assert stats["edge_count"] > 0
+
+
+def test_error_handling_point_too_far_from_network(network_file: Path):
+    """Test error handling when point is too far from any edge."""
+    # Point in the middle of nowhere
+    lat, lon = 0.0, 0.0
+
+    with InMemoryNetworkProcessor(str(network_file)) as processor:
+        # Try to split - should raise error
+        with pytest.raises(ValueError, match="No edges found within"):
+            processor.split_edge_at_point(
+                latitude=lat, longitude=lon, max_search_radius=100
+            )
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_edge_cases.py b/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_edge_cases.py
similarity index 100%
rename from packages/python/goatlib/tests/integration/routing/test_motis_adapter_edge_cases.py
rename to packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_edge_cases.py
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_errors.py b/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_errors.py
similarity index 100%
rename from packages/python/goatlib/tests/integration/routing/test_motis_adapter_errors.py
rename to packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_errors.py
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_fixture.py b/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_fixture.py
similarity index 100%
rename from packages/python/goatlib/tests/integration/routing/test_motis_adapter_fixture.py
rename to packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_fixture.py
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_online.py b/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_online.py
similarity index 100%
rename from packages/python/goatlib/tests/integration/routing/test_motis_adapter_online.py
rename to packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_online.py
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_one_to_all.py b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_adapter_one_to_all.py
similarity index 92%
rename from packages/python/goatlib/tests/integration/routing/test_motis_adapter_one_to_all.py
rename to packages/python/goatlib/tests/integration/routing/catchment/test_motis_adapter_one_to_all.py
index 10d06a5a7..0764089f0 100644
--- a/packages/python/goatlib/tests/integration/routing/test_motis_adapter_one_to_all.py
+++ b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_adapter_one_to_all.py
@@ -6,7 +6,7 @@
 from goatlib.routing.schemas.catchment_area_transit import (
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaStartingPoints,
-    TravelTimeCost,
+    TransitCatchmentAreaTravelTimeCost,
 )
 
 
@@ -51,7 +51,9 @@ async def test_different_transit_modes(self, motis_adapter_online):
             transit_modes=[CatchmentAreaRoutingModePT.rail],
             access_mode=AccessEgressMode.walk,
             egress_mode=AccessEgressMode.walk,
-            travel_cost=TravelTimeCost(max_traveltime=20, cutoffs=[20]),
+            travel_cost=TransitCatchmentAreaTravelTimeCost(
+                max_traveltime=20, cutoffs=[20]
+            ),
         )
 
         response = await motis_adapter_online.get_transit_catchment_area(
@@ -75,7 +77,9 @@ async def test_single_cutoff(self, motis_adapter_online):
             ],
             access_mode=AccessEgressMode.walk,
             egress_mode=AccessEgressMode.walk,
-            travel_cost=TravelTimeCost(max_traveltime=20, cutoffs=[20]),
+            travel_cost=TransitCatchmentAreaTravelTimeCost(
+                max_traveltime=20, cutoffs=[20]
+            ),
         )
 
         response = await motis_adapter_online.get_transit_catchment_area(
@@ -112,7 +116,9 @@ async def test_bike_access_egress(self, motis_adapter_online):
             ],
             access_mode=AccessEgressMode.bicycle,
             egress_mode=AccessEgressMode.bicycle,
-            travel_cost=TravelTimeCost(max_traveltime=25, cutoffs=[25]),
+            travel_cost=TransitCatchmentAreaTravelTimeCost(
+                max_traveltime=25, cutoffs=[25]
+            ),
         )
 
         response = await motis_adapter_online.get_transit_catchment_area(bike_request)
@@ -132,7 +138,9 @@ async def test_invalid_coordinates_handling(self, motis_adapter_online):
             transit_modes=[CatchmentAreaRoutingModePT.bus],
             access_mode=AccessEgressMode.walk,
             egress_mode=AccessEgressMode.walk,
-            travel_cost=TravelTimeCost(max_traveltime=15, cutoffs=[15]),
+            travel_cost=TransitCatchmentAreaTravelTimeCost(
+                max_traveltime=15, cutoffs=[15]
+            ),
         )
 
         response = await motis_adapter_online.get_transit_catchment_area(
diff --git a/packages/python/goatlib/tests/integration/routing/test_motis_bus_station_buffers.py b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_bus_station_buffers.py
similarity index 98%
rename from packages/python/goatlib/tests/integration/routing/test_motis_bus_station_buffers.py
rename to packages/python/goatlib/tests/integration/routing/catchment/test_motis_bus_station_buffers.py
index 2bdcfdd93..0f0c7f777 100644
--- a/packages/python/goatlib/tests/integration/routing/test_motis_bus_station_buffers.py
+++ b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_bus_station_buffers.py
@@ -17,7 +17,7 @@
 from goatlib.routing.schemas.catchment_area_transit import (
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaStartingPoints,
-    TravelTimeCost,
+    TransitCatchmentAreaTravelTimeCost,
 )
 from shapely.geometry import Point
 
@@ -93,7 +93,7 @@ def sample_request() -> TransitCatchmentAreaRequest:
             CatchmentAreaRoutingModePT.tram,
             CatchmentAreaRoutingModePT.rail,
         ],
-        travel_cost=TravelTimeCost(max_traveltime=60, cutoffs=[60]),
+        travel_cost=TransitCatchmentAreaTravelTimeCost(max_traveltime=60, cutoffs=[60]),
     )
 
 
diff --git a/packages/python/goatlib/tests/integration/routing/conftest.py b/packages/python/goatlib/tests/integration/routing/conftest.py
index 96111b55d..40c81a0e6 100644
--- a/packages/python/goatlib/tests/integration/routing/conftest.py
+++ b/packages/python/goatlib/tests/integration/routing/conftest.py
@@ -6,7 +6,7 @@
 from goatlib.routing.schemas.catchment_area_transit import (
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaStartingPoints,
-    TravelTimeCost,
+    TransitCatchmentAreaTravelTimeCost,
 )
 
 
@@ -59,7 +59,7 @@ def berlin_request() -> TransitCatchmentAreaRequest:
         ],
         access_mode=AccessEgressMode.walk,
         egress_mode=AccessEgressMode.walk,
-        travel_cost=TravelTimeCost(
+        travel_cost=TransitCatchmentAreaTravelTimeCost(
             max_traveltime=30,
             cutoffs=[15, 30],  # 15 and 30 minute isochrones
         ),
@@ -82,7 +82,7 @@ def munich_request() -> TransitCatchmentAreaRequest:
         ],
         access_mode=AccessEgressMode.walk,
         egress_mode=AccessEgressMode.walk,
-        travel_cost=TravelTimeCost(
+        travel_cost=TransitCatchmentAreaTravelTimeCost(
             max_traveltime=45,
             cutoffs=[15, 30, 45],  # Three isochrone bands
         ),
@@ -101,5 +101,5 @@ def simple_berlin_request() -> TransitCatchmentAreaRequest:
         transit_modes=[CatchmentAreaRoutingModePT.subway],
         access_mode=AccessEgressMode.walk,
         egress_mode=AccessEgressMode.walk,
-        travel_cost=TravelTimeCost(max_traveltime=15, cutoffs=[15]),
+        travel_cost=TransitCatchmentAreaTravelTimeCost(max_traveltime=15, cutoffs=[15]),
     )
diff --git a/packages/python/goatlib/tests/unit/analysis/test_network.py b/packages/python/goatlib/tests/unit/analysis/test_network.py
new file mode 100644
index 000000000..a0d7e6a4f
--- /dev/null
+++ b/packages/python/goatlib/tests/unit/analysis/test_network.py
@@ -0,0 +1,269 @@
+import logging
+from pathlib import Path
+
+import pytest
+from goatlib.analysis.network.network_processor import (
+    InMemoryNetworkProcessor,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture
+def processor(network_file: Path) -> InMemoryNetworkProcessor:
+    """A pytest fixture that yields a processor within a context manager."""
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        yield proc
+    # Cleanup is handled automatically as the 'with' block exits
+
+
+# ------------ Test Cases ------------
+
+
+def test_network_operations(
+    processor: InMemoryNetworkProcessor,
+) -> None:
+    """Tests chaining non-destructive operations and verifies intermediate results."""
+    base_table_name = processor.network_table_name
+    filtered = processor.apply_sql_query(
+        f"SELECT * FROM {base_table_name} WHERE length_m > 150"
+    )
+
+    # 2. Use the result of the previous step ('filtered') directly in the next query
+    #    The 'base_table' argument is no longer needed.
+    transformed = processor.apply_sql_query(
+        f"SELECT *, length_m * 1.1 as adjusted_length FROM {filtered}"
+    )
+
+    # 3. Use the result of the previous step ('transformed') directly in the next query
+    summary = processor.apply_sql_query(
+        f"SELECT COUNT(*) as total_edges FROM {transformed}"
+    )
+
+    filtered_stats = processor.get_network_stats(filtered)
+    transformed_stats = processor.get_network_stats(transformed)
+    summary_count = processor.con.execute(
+        f"SELECT total_edges FROM {summary}"
+    ).fetchone()[0]
+
+    # Assert that intermediate tables still exist and are correct
+    assert filtered_stats["edge_count"] > 0
+    assert transformed_stats["edge_count"] == filtered_stats["edge_count"]
+    assert summary_count == transformed_stats["edge_count"]
+
+
+def test_save_to_file(processor: InMemoryNetworkProcessor, data_root: Path) -> None:
+    """Test saving a table to a parquet file."""
+    output_file = data_root / "network" / "network_output.parquet"
+    processor.save_table(processor.network_table_name, str(output_file))
+
+    # Verify the file was created
+    assert output_file.exists()
+    assert output_file.stat().st_size > 0
+
+
+def test_save_to_tmp(processor: InMemoryNetworkProcessor) -> None:
+    """Test saving a table to a temporary parquet file."""
+    tmp_file_path = processor.save_table(processor.network_table_name)
+    # Verify the file was created
+    from pathlib import Path
+
+    tmp_file = Path(tmp_file_path)
+    assert tmp_file.exists()
+    assert tmp_file.stat().st_size > 0
+
+
+def test_network_is_wkb_format(processor: InMemoryNetworkProcessor) -> None:
+    """Test that the network geometries are in WKB format."""
+    sample_geometry = processor.con.execute(
+        f"SELECT geometry FROM {processor.network_table_name} LIMIT 1"
+    ).fetchone()[0]
+
+    assert isinstance(
+        sample_geometry, bytes
+    ), f"Geometry should be in WKB format (bytes), got {type(sample_geometry)}"
+
+
+def test_get_available_tables(
+    processor: InMemoryNetworkProcessor,
+) -> None:
+    """Test listing available tables in the in-memory database."""
+    tables = processor.get_available_tables()
+    assert isinstance(tables, list)
+    assert (
+        processor.network_table_name in tables
+    )  # At least the network table should be present
+
+
+def test_edge_split(
+    processor: InMemoryNetworkProcessor,
+) -> None:
+    """
+    Comprehensive test for split operation correctness:
+    - Network metrics are preserved (length, edge count +1)
+    - Topology is correct (original edge removed, 2 new edges added)
+    - New edges have correct naming and connectivity
+    """
+    original_stats = processor.get_network_stats()
+    original_table_name = processor.network_table_name
+
+    split_table, split_meta = processor.split_edge_at_point(
+        latitude=48.13, longitude=11.58
+    )
+
+    # Extract split info from metadata
+    split_info = split_meta.raw_meta["split_operation"]
+    split_stats = processor.get_network_stats(split_table)
+    original_edge_id = split_info["original_edge_split"]
+    new_node_id = split_info["artificial_node_id"]
+
+    # 1. Test Network Metrics Invariance
+    assert split_stats["edge_count"] == original_stats["edge_count"] + 1
+    assert abs(split_stats["total_length_m"] - original_stats["total_length_m"]) < 1.0
+    assert split_stats["avg_length_m"] < original_stats["avg_length_m"]
+
+    # 2. Test Original Edge Removal
+    original_edge_count = processor.con.execute(
+        f"SELECT COUNT(*) FROM {split_table} WHERE edge_id = '{original_edge_id}'"
+    ).fetchone()[0]
+    assert original_edge_count == 0
+
+    # 3. Test New Edge Creation and Naming
+    split_edges = processor.con.execute(f"""
+        SELECT edge_id, source, target FROM {split_table}
+        WHERE edge_id LIKE '{original_edge_id}_part_%' ORDER BY edge_id
+    """).fetchall()
+
+    assert len(split_edges) == 2
+    edge_a, edge_b = split_edges
+
+    # Check naming pattern
+    assert edge_a[0] == f"{original_edge_id}_part_a"
+    assert edge_b[0] == f"{original_edge_id}_part_b"
+
+    # Check connectivity topology
+    assert edge_a[2] == new_node_id  # target of part_a
+    assert edge_b[1] == new_node_id  # source of part_b
+
+    # 4. Test Edge Set Differences (verify exactly what changed)
+    removed_edges = processor.con.execute(f"""
+        SELECT edge_id FROM {original_table_name}
+        EXCEPT SELECT edge_id FROM {split_table}
+    """).fetchall()
+    assert len(removed_edges) == 1
+    assert str(removed_edges[0][0]) == str(original_edge_id)
+
+    added_edges = processor.con.execute(f"""
+        SELECT edge_id FROM {split_table}
+        EXCEPT SELECT edge_id FROM {original_table_name}
+    """).fetchall()
+    added_edge_ids = {row[0] for row in added_edges}
+    assert len(added_edge_ids) == 2
+    assert f"{original_edge_id}_part_a" in added_edge_ids
+    assert f"{original_edge_id}_part_b" in added_edge_ids
+
+
+def test_interpolate_long_edges(processor: InMemoryNetworkProcessor) -> None:
+    """Test edge interpolation functionality."""
+    # Get original network stats
+    original_stats = processor.get_network_stats()
+
+    # Find a reasonable threshold - use 75th percentile of edge lengths
+    edge_lengths = processor.con.execute(f"""
+        SELECT length_m FROM {processor.network_table_name} 
+        ORDER BY length_m DESC
+    """).fetchall()
+
+    if len(edge_lengths) < 4:
+        # Skip test if network is too small
+        return
+
+    # Use a threshold that will catch some but not all edges
+    max_length = edge_lengths[len(edge_lengths) // 4][0]  # 75th percentile
+    interpolation_distance = max_length / 3  # Create multiple segments
+
+    # Perform interpolation
+    interpolated_table, interpolated_meta = processor.interpolate_long_edges(
+        max_edge_length=max_length, interpolation_distance=interpolation_distance
+    )
+
+    # Extract interpolation info from metadata
+    info = interpolated_meta.raw_meta["interpolation_operation"]
+
+    # Verify interpolation info
+    assert info["original_edge_count"] == original_stats["edge_count"]
+    assert info["max_edge_length_threshold"] == max_length
+    assert info["interpolation_distance"] == interpolation_distance
+    assert (
+        info["final_edge_count"] >= info["original_edge_count"]
+    )  # Should have more edges
+    assert info["processing_time_seconds"] > 0
+
+    # Verify the interpolated network has valid stats
+    interpolated_stats = processor.get_network_stats(interpolated_table)
+    assert interpolated_stats["edge_count"] == info["final_edge_count"]
+    assert interpolated_stats["edge_count"] > 0
+
+    # Check that no edge in the interpolated network exceeds the threshold
+    long_edges_count = processor.con.execute(f"""
+        SELECT COUNT(*) FROM {interpolated_table} WHERE length_m > {max_length}
+    """).fetchone()[0]
+    assert (
+        long_edges_count == 0
+    ), f"Found {long_edges_count} edges still longer than {max_length}m"
+
+    # Verify intermediate nodes were created
+    if info["new_intermediate_nodes"] > 0:
+        intermediate_nodes = processor.con.execute(f"""
+            SELECT COUNT(DISTINCT node_id) FROM (
+                SELECT source as node_id FROM {interpolated_table} WHERE source LIKE 'interp_%'
+                UNION 
+                SELECT target as node_id FROM {interpolated_table} WHERE target LIKE 'interp_%'
+            )
+        """).fetchone()[0]
+        assert intermediate_nodes > 0, "Should have created intermediate nodes"
+
+    # Verify total length is preserved (approximately)
+    original_total_length = original_stats["total_length_m"]
+    interpolated_total_length = interpolated_stats["total_length_m"]
+    length_diff = abs(original_total_length - interpolated_total_length)
+    assert (
+        length_diff / original_total_length < 0.01
+    ), f"Total length changed too much: {length_diff}m"
+
+    logger.info("Interpolation test completed:")
+    logger.info(f"  Original edges: {info['original_edge_count']}")
+    logger.info(f"  Long edges processed: {info['long_edges_processed']}")
+    logger.info(f"  Final edges: {info['final_edge_count']}")
+    logger.info(f"  New intermediate nodes: {info['new_intermediate_nodes']}")
+    logger.info(f"  Max edge length threshold: {max_length:.1f}m")
+    logger.info(f"  Processing time: {info['processing_time_seconds']:.2f}s")
+
+
+def test_concurrent_access(network_file: str) -> None:
+    """Test that multiple processors can be created and used concurrently safely."""
+    import concurrent.futures
+
+    from goatlib.analysis.network.network_processor import (
+        InMemoryNetworkProcessor,
+    )
+
+    def create_processor_and_get_stats() -> dict:
+        # Each thread gets its own processor instance with its own connection
+        with InMemoryNetworkProcessor(str(network_file)) as proc:
+            return proc.get_network_stats()
+
+    # Use a smaller number of workers to avoid resource exhaustion
+    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+        futures = [executor.submit(create_processor_and_get_stats) for _ in range(3)]
+        results = [f.result() for f in concurrent.futures.as_completed(futures)]
+
+    # Verify all processors got consistent results
+    for stats in results:
+        assert stats["edge_count"] > 0
+
+    # All results should be identical since they're loading the same file
+    edge_counts = [stats["edge_count"] for stats in results]
+    assert (
+        len(set(edge_counts)) == 1
+    ), "All processors should report the same edge count"
diff --git a/packages/python/goatlib/tests/unit/routing/test_catchment.py b/packages/python/goatlib/tests/unit/routing/test_catchment.py
index 209824e18..b37fb5fc3 100644
--- a/packages/python/goatlib/tests/unit/routing/test_catchment.py
+++ b/packages/python/goatlib/tests/unit/routing/test_catchment.py
@@ -1,9 +1,9 @@
 import pytest
 from goatlib.routing.schemas.base import CatchmentAreaType
-from goatlib.routing.schemas.catchment import CatchmentSchema
+from goatlib.routing.schemas.catchment import Catchment
 from pydantic import ValidationError
 
-"""Test cases for CatchmentSchema validation and functionality."""
+"""Test cases for Catchment validation and functionality."""
 
 
 def test_valid_catchment_schema_creation() -> None:
@@ -17,7 +17,7 @@ def test_valid_catchment_schema_creation() -> None:
         "type": "polygon",
     }
 
-    schema = CatchmentSchema(**data)
+    schema = Catchment(**data)
     assert len(schema.starting_points) == 2
     assert schema.starting_points[0].lon == 11.123
     assert schema.starting_points[0].lat == 48.1234
@@ -39,12 +39,12 @@ def test_coordinate_validation_longitude() -> None:
         "cutoffs": [10.0],
         "type": "point",
     }
-    schema = CatchmentSchema(**valid_data)
+    schema = Catchment(**valid_data)
     assert len(schema.starting_points) == 3
 
     # Invalid longitude - too low
     with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(
+        Catchment(
             starting_points=[{"lon": -180.1, "lat": 48.1}],
             cutoffs=[10.0],
             type="point",
@@ -53,7 +53,7 @@ def test_coordinate_validation_longitude() -> None:
 
     # Invalid longitude - too high
     with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(
+        Catchment(
             starting_points=[{"lon": 180.1, "lat": 48.1}],
             cutoffs=[10.0],
             type="point",
@@ -73,12 +73,12 @@ def test_coordinate_validation_latitude() -> None:
         "cutoffs": [10.0],
         "type": "point",
     }
-    schema = CatchmentSchema(**valid_data)
+    schema = Catchment(**valid_data)
     assert len(schema.starting_points) == 3
 
     # Invalid latitude - too low
     with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(
+        Catchment(
             starting_points=[{"lon": 11.0, "lat": -90.1}],
             cutoffs=[10.0],
             type="point",
@@ -87,7 +87,7 @@ def test_coordinate_validation_latitude() -> None:
 
     # Invalid latitude - too high
     with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(
+        Catchment(
             starting_points=[{"lon": 11.0, "lat": 90.1}],
             cutoffs=[10.0],
             type="point",
@@ -99,7 +99,7 @@ def test_invalid_coordinate_count() -> None:
     """Test validation of coordinate structure."""
     # Missing required field
     with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(
+        Catchment(
             starting_points=[{"lon": 11.123}],  # Missing lat
             cutoffs=[10.0],
             type="point",
@@ -108,7 +108,7 @@ def test_invalid_coordinate_count() -> None:
 
     # Invalid format (list instead of dict)
     with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(
+        Catchment(
             starting_points=[[11.123, 48.1234]],  # Should be dict
             cutoffs=[10.0],
             type="point",
@@ -119,22 +119,10 @@ def test_invalid_coordinate_count() -> None:
 def test_empty_starting_points() -> None:
     """Test validation with empty starting points."""
     with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(starting_points=[], cutoffs=[10.0], type="point")
+        Catchment(starting_points=[], cutoffs=[10.0], type="point")
     assert "at least 1" in str(exc_info.value).lower()
 
 
-def test_too_many_starting_points() -> None:
-    """Test validation with many starting points (no hard limit, just verify it works)."""
-    # Create 101 points to verify system can handle many points
-    many_points = [
-        {"lon": 11.0 + i * 0.001, "lat": 48.0 + i * 0.001} for i in range(101)
-    ]
-
-    # Should not raise an error - just verify it works
-    schema = CatchmentSchema(starting_points=many_points, cutoffs=[10.0], type="point")
-    assert len(schema.starting_points) == 101
-
-
 def test_cutoffs_validation() -> None:
     """Test cutoffs validation."""
     base_data = {
@@ -144,23 +132,23 @@ def test_cutoffs_validation() -> None:
 
     # Negative cutoff
     with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(cutoffs=[-5.0], **base_data)
+        Catchment(cutoffs=[-5.0], **base_data)
     assert "must be positive" in str(exc_info.value)
 
     # Zero cutoff
     with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(cutoffs=[0.0], **base_data)
+        Catchment(cutoffs=[0.0], **base_data)
     assert "must be positive" in str(exc_info.value)
 
     # Unsorted cutoffs should be auto-sorted without error
-    schema = CatchmentSchema(cutoffs=[20.0, 10.0, 30.0], **base_data)
+    schema = Catchment(cutoffs=[20.0, 10.0, 30.0], **base_data)
     assert schema.cutoffs == [10.0, 20.0, 30.0]
 
 
 def test_empty_cutoffs() -> None:
     """Test validation with empty cutoffs."""
     with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(
+        Catchment(
             starting_points=[{"lon": 11.123, "lat": 48.1234}],
             cutoffs=[],
             type="point",
@@ -168,24 +156,10 @@ def test_empty_cutoffs() -> None:
     assert "at least 1" in str(exc_info.value).lower()
 
 
-def test_too_many_cutoffs() -> None:
-    """Test validation with too many cutoffs."""
-    # Create 11 cutoffs (exceeds max of 10)
-    too_many_cutoffs = [float(i) for i in range(1, 12)]
-
-    with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(
-            starting_points=[{"lon": 11.123, "lat": 48.1234}],
-            cutoffs=too_many_cutoffs,
-            type="point",
-        )
-    assert "at most 10" in str(exc_info.value).lower()
-
-
 def test_invalid_catchment_type() -> None:
     """Test validation with invalid catchment type."""
     with pytest.raises(ValidationError) as exc_info:
-        CatchmentSchema(
+        Catchment(
             starting_points=[{"lon": 11.123, "lat": 48.1234}],
             cutoffs=[10.0],
             type="invalid_type",
@@ -204,7 +178,7 @@ def test_example_from_user_request() -> None:
         "type": "polygon",
     }
 
-    schema = CatchmentSchema(**data)
+    schema = Catchment(**data)
     assert len(schema.starting_points) == 2
     assert schema.starting_points[0].lon == 11.123
     assert schema.starting_points[0].lat == 12.34
@@ -212,13 +186,3 @@ def test_example_from_user_request() -> None:
     assert schema.starting_points[1].lat == 48.1234
     assert schema.cutoffs == [10.0, 20.0, 30.0]
     assert schema.type == CatchmentAreaType.polygon
-
-
-"""Test cases for CatchmentAreaType enum."""
-
-
-def test_all_catchment_types_available() -> None:
-    """Test that all expected catchment types are available."""
-    expected_types = {"point", "network", "grid", "polygon"}
-    available_types = {t.value for t in CatchmentAreaType}
-    assert available_types == expected_types
diff --git a/packages/python/goatlib/tests/unit/routing/test_route_validation.py b/packages/python/goatlib/tests/unit/routing/test_route_validation.py
index b4856d482..79bfa98d5 100644
--- a/packages/python/goatlib/tests/unit/routing/test_route_validation.py
+++ b/packages/python/goatlib/tests/unit/routing/test_route_validation.py
@@ -2,7 +2,8 @@
 
 from goatlib.routing.schemas.ab_routing import ABLeg, ABRoute
 from goatlib.routing.schemas.base import Coordinates, Mode
-from goatlib.routing.utils.ab_route_validator import (
+
+from packages.python.goatlib.tests.utils.ab_route_validator import (
     validate_route_response,
     validate_single_route,
 )
diff --git a/packages/python/goatlib/src/goatlib/routing/utils/__init__.py b/packages/python/goatlib/tests/utils/__init__.py
similarity index 100%
rename from packages/python/goatlib/src/goatlib/routing/utils/__init__.py
rename to packages/python/goatlib/tests/utils/__init__.py
diff --git a/packages/python/goatlib/src/goatlib/routing/utils/ab_route_validator.py b/packages/python/goatlib/tests/utils/ab_route_validator.py
similarity index 100%
rename from packages/python/goatlib/src/goatlib/routing/utils/ab_route_validator.py
rename to packages/python/goatlib/tests/utils/ab_route_validator.py

From 72ce07b4818b3cea75575ed0447ff138cae1c919 Mon Sep 17 00:00:00 2001
From: 96hoshi <marta.locascio@plan4better.de>
Date: Thu, 11 Dec 2025 17:04:06 +0000
Subject: [PATCH 05/11] fix: trying to improve splitting edge method

---
 .../analysis/network/network_processor.py     | 659 +++++++++---------
 .../tests/unit/analysis/test_network.py       | 184 ++---
 2 files changed, 378 insertions(+), 465 deletions(-)

diff --git a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
index 284197293..295e7ae85 100644
--- a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
+++ b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
@@ -1,14 +1,15 @@
 import logging
 import uuid
-from typing import Any, Dict
+import time
+from typing import Any, Dict, Tuple
 
 from goatlib.analysis.core.base import AnalysisTool
 from goatlib.io.utils import Metadata
+from goatlib.routing.schemas.base import Coordinates
 
 logger = logging.getLogger(__name__)
 
 # from .super I have only: cleanup, init and import_input
-# TODO make it dependent by a coordinate pair to buffer the network area around it
 
 
 class InMemoryNetworkProcessor(AnalysisTool):
@@ -19,9 +20,9 @@ class InMemoryNetworkProcessor(AnalysisTool):
     def __init__(self, input_path: str) -> None:
         """Initializes the processor. Requires network parameters to be valid."""
         super().__init__(db_path=input_path)
-        self.input_path = input_path
-        self.network_table_name = None
         self._is_loaded = False
+        self._network_table_name: str
+        self._meta: Metadata
 
     def __enter__(self) -> "InMemoryNetworkProcessor":
         """Enters the context, loading the network and returning the processor instance."""
@@ -33,16 +34,31 @@ def __exit__(self, exc_type, exc_val, exc_tb) -> None:
         """Exits the context, automatically cleaning up all database resources."""
         super().cleanup()
 
-    # Public API Methods
-    def get_network_metadata(self) -> Metadata:
-        """Get metadata about the loaded network using AnalysisTool metadata functionality."""
+    @property
+    def network_table_name(self) -> str:
+        """Get the name of the loaded network table."""
         self._ensure_loaded()
-        return self.meta
+        return self._network_table_name
+
+    @property
+    def network_metadata(self) -> Metadata:
+        """Get metadata about the loaded network."""
+        self._ensure_loaded()
+        return self._meta
+
+    def _ensure_loaded(self) -> None:
+        """Ensure the network is loaded before performing operations."""
+        if not self._is_loaded:
+            raise RuntimeError("Network not loaded. Call load_network() first.")
 
     def get_network_stats(self, table_name: str = None) -> Dict[str, Any]:
-        """Get basic statistics about the network."""
+        """Get basic statistics about the network.
+
+        Args:
+            table_name: Optional table name to get stats for. If None, uses the main network table.
+        """
         self._ensure_loaded()
-        target_table = table_name or self.network_table_name
+        target_table = table_name if table_name else self._network_table_name
         result = self.con.execute(f"""
             SELECT
                 COUNT(*) as edge_count,
@@ -65,163 +81,143 @@ def get_available_tables(self) -> list[str]:
         result = self.con.execute("SHOW TABLES").fetchall()
         return [row[0] for row in result]
 
-    def create_buffered_subset(
+    def apply_sql_query(
+        self, sql_query: str, result_table: str = "query_result"
+    ) -> str:
+        """Applies SQL and returns a NEW table, without destroying the input."""
+        self._ensure_loaded()
+        result_table = f"{result_table}_{uuid.uuid4().hex[:8]}"
+        try:
+            # WARNING: This does not sanitize input SQL - use with caution in production
+            self.con.execute(f"CREATE TABLE {result_table} AS {sql_query}")
+            logger.info(f"Created result table: {result_table}")
+            return result_table
+        except Exception as e:
+            logger.error(f"Failed to execute SQL query: {e}")
+            raise
+
+    def load_network(
         self,
-        latitude: float,
-        longitude: float,
-        buffer_radius: float = 5000.0,
-        base_table: str = None,
+        center: Coordinates = None,
+        buffer_radius: float = None,
+        travel_time_minutes: float = 90.0,
+        speed_kmh: float = 5.0,
     ) -> str:
         """
-        Create a subset of the network within a buffer around a point.
-        This dramatically reduces memory and processing time for local operations.
-
-        Use this method BEFORE performing expensive operations like splitting or
-        interpolation to work only with relevant network edges.
-
-        Args:
-            latitude: Center point latitude
-            longitude: Center point longitude
-            buffer_radius: Buffer distance in meters (default: 5km)
-            base_table: Source table (defaults to main network table)
+        Cut network for routing operations with configurable parameters.
 
         Returns:
-            Name of the created subset table
-
-        Example:
-            >>> processor = InMemoryNetworkProcessor("network.parquet")
-            >>> # Load network and create 3km subset around Munich center
-            >>> subset = processor.create_buffered_subset(48.1351, 11.5820, 3000)
-            >>> # Get metadata with statistics
-            >>> meta = processor.get_subset_metadata(subset, 48.1351, 11.5820, 3000)
-            >>> # Now work only on the subset (much faster!)
-            >>> split, _ = processor.split_edge_at_point(48.135, 11.582, base_table=subset)
-        """
-        self._ensure_loaded()
-        source_table = base_table or self.network_table_name
-        subset_table_name = f"buffered_network_{uuid.uuid4().hex[:8]}"
-        geom_col = self.meta.geometry_column
-
-        # Create point and buffer using DuckDB spatial functions
-        subset_query = f"""
-        CREATE TABLE {subset_table_name} AS
-        WITH buffer_geom AS (
-            SELECT ST_Buffer(
-                ST_Point({longitude}, {latitude}),
-                {buffer_radius}
-            ) AS buffer
-        )
-        SELECT t.*
-        FROM {source_table} t, buffer_geom
-        WHERE ST_Intersects(t.{geom_col}, buffer_geom.buffer)
+            Tuple of (table_name, buffer_distance_meters)
         """
+        self._meta, self._network_table_name = super().import_input(self._db_path)
+        logger.info(f"Network loaded into table: {self._network_table_name}")
 
-        self.con.execute(subset_query)
+        # Validate required columns exist
+        # TODO check if this is made in import_input
+        if not self._meta.geometry_column:
+            raise ValueError("Network file must have a geometry column")
 
-        # Get basic edge count for logging
-        edge_count = self.con.execute(
-            f"SELECT COUNT(*) FROM {subset_table_name}"
-        ).fetchone()[0]
-        original_count = self.con.execute(
-            f"SELECT COUNT(*) FROM {source_table}"
-        ).fetchone()[0]
+        if center is None:
+            logger.info("No center provided, loading full network")
+            self._is_loaded = True
+            return self._network_table_name
+        # Calculate buffer distance
+        if buffer_radius is not None:
+            buffer_distance = buffer_radius
+        else:
+            # Convert travel time to distance
+            # speed_kmh * 1000 / 60 = meters per minute
+            buffer_distance = travel_time_minutes * (speed_kmh * 1000 / 60)
+
+        # Convert meters to degrees (approximate at the given latitude)
+        # DuckDB spatial doesn't have ST_DWithin_Sphere, so we convert to degrees
+        import math
+
+        lat_rad = math.radians(center.lat)
+        meters_per_degree_lat = 111320  # roughly constant
+        meters_per_degree_lon = 111320 * math.cos(lat_rad)
+        # Use average for simplicity
+        buffer_degrees = buffer_distance / (
+            (meters_per_degree_lat + meters_per_degree_lon) / 2
+        )
 
         logger.info(
-            f"Created buffered subset: {edge_count}/{original_count} edges "
-            f"({edge_count/original_count*100:.1f}% of original) "
-            f"within {buffer_radius}m of ({latitude}, {longitude})"
+            f"Creating buffered network subset with buffer distance: {buffer_distance:.2f} meters "
+            f"(~{buffer_degrees:.6f} degrees)"
         )
 
+        # Create buffered network
+        subset_table_name = f"routing_network_{uuid.uuid4().hex[:8]}"
+
+        subset_query = f"""
+            CREATE TABLE {subset_table_name} AS
+            SELECT t.*
+            FROM {self._network_table_name} t
+            WHERE ST_Intersects(
+                t.{self._meta.geometry_column},
+                ST_Buffer(
+                    ST_Point({center.lon}, {center.lat}),
+                    {buffer_degrees}
+                )
+            )
+            """
+
+        import time
+
+        start = time.time()
+        self.con.execute(subset_query)
+        elapsed = time.time() - start
+
+        logger.info(f"Network subset created in {elapsed:.3f} seconds")
+        self._is_loaded = True
+
         return subset_table_name
 
-    def get_subset_metadata(
+    # Network Analysis Methods
+    def split_edge_at_point_with_subset(
         self,
-        subset_table: str,
-        latitude: float,
-        longitude: float,
-        buffer_radius: float,
-        source_table: str = None,
-    ) -> Metadata:
+        point: Coordinates,
+        network_buffer_radius: float = 500.0,
+        max_search_radius: float = 20.0,
+    ) -> tuple[str, Metadata]:
         """
-        Get metadata for a buffered subset table with detailed statistics.
+        Loads a network subset around a point and splits the nearest edge.
+
+        This is memory-efficient as it only loads the network within the buffer radius.
 
         Args:
-            subset_table: Name of the subset table
-            latitude: Center point latitude used for buffer
-            longitude: Center point longitude used for buffer
-            buffer_radius: Buffer radius in meters
-            source_table: Original source table (defaults to main network table)
+            point: Coordinates where to split
+            network_buffer_radius: Radius in meters to load network around the point (default: 500m)
+            max_search_radius: Maximum search radius in meters for finding closest edge (default: 200m)
+            include_stats: Whether to include edge count statistics
 
         Returns:
-            Metadata object with buffer operation details in raw_meta
-        """
-        self._ensure_loaded()
-        source_table = source_table or self.network_table_name
-        geom_col = self.meta.geometry_column
-
-        # Create metadata for subset table
-        subset_meta = self._create_metadata_from_template(subset_table)
-
-        # Get statistics about the subset
-        stats_query = f"""
-        SELECT
-            COUNT(*) as subset_edges,
-            (SELECT COUNT(*) FROM {source_table}) as original_edges,
-            SUM(length_m) as total_length_m,
-            MIN(ST_Distance({geom_col}, ST_Point({longitude}, {latitude}))) as min_distance,
-            MAX(ST_Distance({geom_col}, ST_Point({longitude}, {latitude}))) as max_distance
-        FROM {subset_table}
+            Tuple of (table_name, metadata) with split operation details
         """
+        # Load only the network subset around the point
+        logger.info(
+            f"Loading network subset with {network_buffer_radius}m radius around point"
+        )
+        subset_table = self.load_network(
+            center=point, buffer_radius=network_buffer_radius
+        )
 
-        stats_result = self.con.execute(stats_query).fetchone()
-
-        # Add buffer operation details to metadata
-        subset_meta.raw_meta = subset_meta.raw_meta or {}
-        subset_meta.raw_meta["buffer_operation"] = {
-            "operation": "spatial_buffer",
-            "center_point": {"lat": latitude, "lon": longitude},
-            "buffer_radius_m": buffer_radius,
-            "original_edge_count": stats_result[1],
-            "subset_edge_count": stats_result[0],
-            "reduction_ratio": stats_result[0] / stats_result[1]
-            if stats_result[1] > 0
-            else 0,
-            "total_length_m": float(stats_result[2]) if stats_result[2] else 0,
-            "min_distance_m": float(stats_result[3]) if stats_result[3] else 0,
-            "max_distance_m": float(stats_result[4]) if stats_result[4] else 0,
-        }
-
-        return subset_meta
-
-    def apply_sql_query(
-        self, sql_query: str, result_table: str = "query_result"
-    ) -> str:
-        """Applies SQL and returns a NEW table, without destroying the input."""
-        self._ensure_loaded()
-        result_table = f"{result_table}_{uuid.uuid4().hex[:8]}"
-        try:
-            # WARNING: This does not sanitize input SQL - use with caution in production
-            self.con.execute(f"CREATE TABLE {result_table} AS {sql_query}")
-            logger.info(f"Created result table: {result_table}")
-            return result_table
-        except Exception as e:
-            logger.error(f"Failed to execute SQL query: {e}")
-            raise
+        # Now split on this subset
+        return self.split_edge_at_point(
+            point=point,
+            source_table=subset_table,
+            max_search_radius=max_search_radius,
+        )
 
-    # Network Analysis Methods
     def split_edge_at_point(
         self,
-        latitude: float,
-        longitude: float,
-        base_table: str = None,
-        max_search_radius: float = 200.0,
-        include_stats: bool = True,
+        point: Coordinates,
+        source_table: str = None,
+        max_search_radius: float = 100.0,
     ) -> tuple[str, Metadata]:
         """
         Finds the closest edge to a point, splits it, and creates a new network table.
 
-        Uses bbox optimization with spatial indexing for efficient edge searching.
-
         Args:
             latitude: Latitude of the split point
             longitude: Longitude of the split point
@@ -232,46 +228,61 @@ def split_edge_at_point(
         Returns:
             Tuple of (table_name, metadata) with split operation details in raw_meta
         """
-        self._ensure_loaded()
-        source_table = base_table or self.network_table_name
         split_table_name = f"split_network_{uuid.uuid4().hex[:8]}"
         new_node_id = f"split_node_{uuid.uuid4().hex[:8]}"
-        point_geom = f"ST_Point({longitude}, {latitude})"
-        geom_col = self.meta.geometry_column
-
-        # Calculate rough bbox around the point (in degrees, approximate)
-        bbox_size = max_search_radius / 111000.0  # rough meters to degrees conversion
+        point_geom = f"ST_Point({point.lon}, {point.lat})"
+        geom_col = self._meta.geometry_column
 
+        # First, find the closest edge using bbox optimization
         info_query = f"""
+        WITH search_bbox AS (
+            SELECT ST_Envelope(
+                ST_Buffer({point_geom}, {max_search_radius})
+            ) AS bbox
+        ), candidate_edges AS (
+            SELECT *
+            FROM {source_table}, search_bbox
+            WHERE ST_Intersects({geom_col}, search_bbox.bbox)
+        ), closest_edge AS (
+            SELECT
+                edge_id,
+                ST_Distance({geom_col}, {point_geom}) AS distance,
+                ST_LineLocatePoint({geom_col}, {point_geom}) AS split_fraction,
+                {geom_col}
+            FROM candidate_edges
+            ORDER BY distance ASC
+            LIMIT 1
+        ), split_point_calc AS (
+            SELECT
+                edge_id,
+                split_fraction,
+                distance,
+                ST_X(ST_LineInterpolatePoint({geom_col}, split_fraction)) AS split_lon,
+                ST_Y(ST_LineInterpolatePoint({geom_col}, split_fraction)) AS split_lat
+            FROM closest_edge
+        )
         SELECT
             edge_id,
-            ST_LineLocatePoint({geom_col}, {point_geom}) as split_fraction,
-            ST_X(ST_LineInterpolatePoint({geom_col}, ST_LineLocatePoint({geom_col}, {point_geom}))) as split_lon,
-            ST_Y(ST_LineInterpolatePoint({geom_col}, ST_LineLocatePoint({geom_col}, {point_geom}))) as split_lat,
-            ST_Distance({geom_col}, {point_geom}) as distance
-        FROM {source_table}
-        WHERE ST_Intersects({geom_col}, ST_MakeEnvelope(
-            {longitude - bbox_size}, {latitude - bbox_size},
-            {longitude + bbox_size}, {latitude + bbox_size}
-        ))
-        AND ST_Distance({geom_col}, {point_geom}) <= {max_search_radius}
-        ORDER BY ST_Distance({geom_col}, {point_geom}) ASC
-        LIMIT 1
+            split_fraction,
+            split_lon,
+            split_lat,
+            distance
+        FROM split_point_calc;
         """
-
+        find_start = time.time()
         info_res = self.con.execute(info_query).fetchone()
 
         # Check if any edge was found
         if not info_res or info_res[0] is None:
             raise ValueError(
-                f"No edges found within {max_search_radius}m of point ({latitude}, {longitude}). "
-                f"Try increasing max_search_radius or check if the point is near the network."
+                "No edges found. Try increasing max_search_radius or check if the point is near the network."
             )
+        find_elapsed = time.time() - find_start
+        logger.info(f"Found closest edge in {find_elapsed:.3f}s")
 
-        # Extract info for later use
+        # Now create the split table using the found edge
         original_edge_id, split_fraction, split_lon, split_lat, distance = info_res
 
-        # Now create the split table using the found edge
         split_query = f"""
         CREATE TABLE {split_table_name} AS
         WITH target_edge AS (
@@ -309,10 +320,18 @@ def split_edge_at_point(
         UNION ALL
         SELECT * FROM new_split_parts;
         """
+
+        split_start = time.time()
         self.con.execute(split_query)
+        split_elapsed = time.time() - split_start
+        logger.info(f"Created split table in {split_elapsed:.3f}s")
 
-        # Create metadata for the split table using fast path (same schema as original)
-        split_meta = self._create_metadata_from_template(split_table_name)
+        logger.info(
+            f"Original edge '{original_edge_id}' split at fraction {split_fraction:.6f} "
+            f"({distance:.2f}m from point) into new node '{new_node_id}'"
+        )
+        # Create metadata for the split table (copy from original)
+        split_meta = Metadata(geometry_column=self._meta.geometry_column, raw_meta={})
 
         # Add split operation details to metadata
         split_operation_info = {
@@ -329,17 +348,6 @@ def split_edge_at_point(
             },
         }
 
-        # Optionally include statistics (can be expensive for large networks)
-        if include_stats:
-            split_operation_info.update(
-                {
-                    "original_edge_count": self.get_network_stats()["edge_count"],
-                    "split_edge_count": self.get_network_stats(split_table_name)[
-                        "edge_count"
-                    ],
-                }
-            )
-
         split_meta.raw_meta["split_operation"] = split_operation_info
 
         # Warning for edge cases
@@ -351,142 +359,142 @@ def split_edge_at_point(
 
         return split_table_name, split_meta
 
-    def interpolate_long_edges(
-        self,
-        max_edge_length: float,
-        base_table: str = None,
-        interpolation_distance: float = None,
-    ) -> tuple[str, Metadata]:
-        """
-        Interpolate nodes along edges that are longer than the specified threshold.
-        Creates actual intermediate nodes with coordinates and splits edges accordingly.
-
-        Args:
-            max_edge_length: Maximum allowed edge length in meters
-            base_table: Table to process (defaults to main network table)
-            interpolation_distance: Distance between interpolated points (defaults to max_edge_length/2)
-
-        Returns:
-            Tuple of (table_name, metadata) where metadata contains table schema
-            and interpolation details in raw_meta
-        """
-        import time
-
-        start_time = time.time()
-        self._ensure_loaded()
-        source_table = base_table or self.network_table_name
-        interpolated_table = self._generate_table_name("interpolated_network")
-
-        # Default interpolation distance
-        if interpolation_distance is None:
-            interpolation_distance = max_edge_length / 2
-
-        # Use metadata geometry column for dynamic column handling
-        geom_column = self.meta.geometry_column
-
-        # Combined query: create table and get statistics in one go
-        interpolation_query = f"""
-        CREATE TABLE {interpolated_table} AS
-        WITH original_stats AS (
-            SELECT
-                COUNT(*) as original_edges,
-                COUNT(*) FILTER (WHERE length_m > {max_edge_length}) as long_edges_count
-            FROM {source_table}
-        ),
-        long_edges AS (
-            -- Identify edges that need interpolation and calculate segments needed
-            SELECT *,
-                   CAST(CEIL(length_m / {interpolation_distance}) AS INTEGER) as num_segments
-            FROM {source_table}
-            WHERE length_m > {max_edge_length}
-        ),
-        interpolated_segments AS (
-            -- Generate new edges with intermediate nodes
-            SELECT
-                edge_id || '_seg_' || CAST(segment_id AS VARCHAR) as edge_id,
-                CASE
-                    WHEN segment_id = 1 THEN CAST(source AS VARCHAR)
-                    ELSE 'interp_' || edge_id || '_' || CAST((segment_id - 1) AS VARCHAR)
-                END as source,
-                CASE
-                    WHEN segment_id = num_segments THEN CAST(target AS VARCHAR)
-                    ELSE 'interp_' || edge_id || '_' || CAST(segment_id AS VARCHAR)
-                END as target,
-                length_m / num_segments as length_m,
-                cost / num_segments as cost,
-                ST_LineSubstring(
-                    {geom_column},
-                    (segment_id - 1.0) / num_segments,
-                    segment_id / num_segments
-                ) as {geom_column}
-            FROM long_edges
-            CROSS JOIN generate_series(1, num_segments) as t(segment_id)
-        )
-        -- Combine short edges (unchanged) with interpolated segments
-        SELECT edge_id, source, target, length_m, cost, {geom_column}
-        FROM {source_table}
-        WHERE length_m <= {max_edge_length}
-
-        UNION ALL
-
-        SELECT edge_id, source, target, length_m, cost, {geom_column}
-        FROM interpolated_segments
-        ORDER BY edge_id;
-        """
-
-        self.con.execute(interpolation_query)
-        processing_time = time.time() - start_time
-
-        # Get statistics in single optimized query
-        stats_query = f"""
-        WITH original_stats AS (
-            SELECT
-                COUNT(*) as original_edges,
-                COUNT(*) FILTER (WHERE length_m > {max_edge_length}) as long_edges_count
-            FROM {source_table}
-        ),
-        new_stats AS (
-            SELECT COUNT(*) as new_edges FROM {interpolated_table}
-        ),
-        node_stats AS (
-            SELECT
-                COUNT(DISTINCT source) + COUNT(DISTINCT target) as total_nodes,
-                COUNT(DISTINCT source) FILTER (WHERE source LIKE 'interp_%') +
-                COUNT(DISTINCT target) FILTER (WHERE target LIKE 'interp_%') as new_nodes
-            FROM {interpolated_table}
-        )
-        SELECT
-            o.original_edges,
-            o.long_edges_count,
-            n.new_edges,
-            ns.new_nodes,
-            ns.total_nodes
-        FROM original_stats o, new_stats n, node_stats ns;
-        """
-
-        stats_result = self.con.execute(stats_query).fetchone()
-
-        # Create metadata for the interpolated table using fast path
-        interpolated_meta = self._create_metadata_from_template(interpolated_table)
-
-        # Embed interpolation details in raw_meta
-        interpolated_meta.raw_meta = interpolated_meta.raw_meta or {}
-        interpolated_meta.raw_meta["interpolation_operation"] = {
-            "original_edge_count": stats_result[0],
-            "long_edges_processed": stats_result[1],
-            "final_edge_count": stats_result[2],
-            "new_intermediate_nodes": stats_result[3],
-            "total_nodes": stats_result[4],
-            "edges_added": stats_result[2] - stats_result[0],
-            "max_edge_length_threshold": max_edge_length,
-            "interpolation_distance": interpolation_distance,
-            "processing_time_seconds": processing_time,
-        }
-
-        return interpolated_table, interpolated_meta
+    # def interpolate_long_edges(
+    #     self,
+    #     max_edge_length: float,
+    #     base_table: str = None,
+    #     interpolation_distance: float = None,
+    # ) -> tuple[str, Metadata]:
+    #     """
+    #     Interpolate nodes along edges that are longer than the specified threshold.
+    #     Creates actual intermediate nodes with coordinates and splits edges accordingly.
+
+    #     Args:
+    #         max_edge_length: Maximum allowed edge length in meters
+    #         base_table: Table to process (defaults to main network table)
+    #         interpolation_distance: Distance between interpolated points (defaults to max_edge_length/2)
+
+    #     Returns:
+    #         Tuple of (table_name, metadata) where metadata contains table schema
+    #         and interpolation details in raw_meta
+    #     """
+    #     import time
+
+    #     start_time = time.time()
+    #     self._ensure_loaded()
+    #     source_table = base_table or self.network_table_name
+    #     interpolated_table = self._generate_table_name("interpolated_network")
+
+    #     # Default interpolation distance
+    #     if interpolation_distance is None:
+    #         interpolation_distance = max_edge_length / 2
+
+    #     # Use metadata geometry column for dynamic column handling
+    #     geom_column = self.meta.geometry_column
+
+    #     # Combined query: create table and get statistics in one go
+    #     interpolation_query = f"""
+    #     CREATE TABLE {interpolated_table} AS
+    #     WITH original_stats AS (
+    #         SELECT
+    #             COUNT(*) as original_edges,
+    #             COUNT(*) FILTER (WHERE length_m > {max_edge_length}) as long_edges_count
+    #         FROM {source_table}
+    #     ),
+    #     long_edges AS (
+    #         -- Identify edges that need interpolation and calculate segments needed
+    #         SELECT *,
+    #                CAST(CEIL(length_m / {interpolation_distance}) AS INTEGER) as num_segments
+    #         FROM {source_table}
+    #         WHERE length_m > {max_edge_length}
+    #     ),
+    #     interpolated_segments AS (
+    #         -- Generate new edges with intermediate nodes
+    #         SELECT
+    #             edge_id || '_seg_' || CAST(segment_id AS VARCHAR) as edge_id,
+    #             CASE
+    #                 WHEN segment_id = 1 THEN CAST(source AS VARCHAR)
+    #                 ELSE 'interp_' || edge_id || '_' || CAST((segment_id - 1) AS VARCHAR)
+    #             END as source,
+    #             CASE
+    #                 WHEN segment_id = num_segments THEN CAST(target AS VARCHAR)
+    #                 ELSE 'interp_' || edge_id || '_' || CAST(segment_id AS VARCHAR)
+    #             END as target,
+    #             length_m / num_segments as length_m,
+    #             cost / num_segments as cost,
+    #             ST_LineSubstring(
+    #                 {geom_column},
+    #                 (segment_id - 1.0) / num_segments,
+    #                 segment_id / num_segments
+    #             ) as {geom_column}
+    #         FROM long_edges
+    #         CROSS JOIN generate_series(1, num_segments) as t(segment_id)
+    #     )
+    #     -- Combine short edges (unchanged) with interpolated segments
+    #     SELECT edge_id, source, target, length_m, cost, {geom_column}
+    #     FROM {source_table}
+    #     WHERE length_m <= {max_edge_length}
+
+    #     UNION ALL
+
+    #     SELECT edge_id, source, target, length_m, cost, {geom_column}
+    #     FROM interpolated_segments
+    #     ORDER BY edge_id;
+    #     """
+
+    #     self.con.execute(interpolation_query)
+    #     processing_time = time.time() - start_time
+
+    #     # Get statistics in single optimized query
+    #     stats_query = f"""
+    #     WITH original_stats AS (
+    #         SELECT
+    #             COUNT(*) as original_edges,
+    #             COUNT(*) FILTER (WHERE length_m > {max_edge_length}) as long_edges_count
+    #         FROM {source_table}
+    #     ),
+    #     new_stats AS (
+    #         SELECT COUNT(*) as new_edges FROM {interpolated_table}
+    #     ),
+    #     node_stats AS (
+    #         SELECT
+    #             COUNT(DISTINCT source) + COUNT(DISTINCT target) as total_nodes,
+    #             COUNT(DISTINCT source) FILTER (WHERE source LIKE 'interp_%') +
+    #             COUNT(DISTINCT target) FILTER (WHERE target LIKE 'interp_%') as new_nodes
+    #         FROM {interpolated_table}
+    #     )
+    #     SELECT
+    #         o.original_edges,
+    #         o.long_edges_count,
+    #         n.new_edges,
+    #         ns.new_nodes,
+    #         ns.total_nodes
+    #     FROM original_stats o, new_stats n, node_stats ns;
+    #     """
+
+    #     stats_result = self.con.execute(stats_query).fetchone()
+
+    #     # Create metadata for the interpolated table using fast path
+    #     interpolated_meta = self._create_metadata_from_template(interpolated_table)
+
+    #     # Embed interpolation details in raw_meta
+    #     interpolated_meta.raw_meta = interpolated_meta.raw_meta or {}
+    #     interpolated_meta.raw_meta["interpolation_operation"] = {
+    #         "original_edge_count": stats_result[0],
+    #         "long_edges_processed": stats_result[1],
+    #         "final_edge_count": stats_result[2],
+    #         "new_intermediate_nodes": stats_result[3],
+    #         "total_nodes": stats_result[4],
+    #         "edges_added": stats_result[2] - stats_result[0],
+    #         "max_edge_length_threshold": max_edge_length,
+    #         "interpolation_distance": interpolation_distance,
+    #         "processing_time_seconds": processing_time,
+    #     }
+
+    #     return interpolated_table, interpolated_meta
 
     # File I/O Methods
-    def save_table(
+    def save_network(
         self,
         table_name: str,
         output_path: str | None = None,
@@ -528,36 +536,3 @@ def quote_ident(name: str) -> str:
             )
 
         return output_path
-
-    # Private Helper Methods
-    def _ensure_loaded(self) -> None:
-        if not self._is_loaded:
-            self._load_network()
-
-    def _load_network(self) -> None:
-        """Load the network file using the parent class import functionality."""
-        if self._is_loaded:
-            return
-
-        # Import using the parent class method which handles metadata correctly
-        self.meta, self.network_table_name = super().import_input(self.input_path)
-
-        # Network loaded - use create_buffered_subset() to work with a subset for performance
-        self._is_loaded = True
-
-        # Validate required columns exist
-        required_columns = {"edge_id", "source", "target", "geometry"}
-
-        # Get actual column names from metadata
-        actual_columns = {col.name for col in self.meta.columns}
-
-        missing_columns = required_columns - actual_columns
-        if missing_columns:
-            raise ValueError(
-                f"Network file missing required columns: {missing_columns}. "
-                f"Available columns: {actual_columns}"
-            )
-
-        # Validate geometry column exists
-        if not self.meta.geometry_column:
-            raise ValueError("Network file must have a geometry column")
diff --git a/packages/python/goatlib/tests/unit/analysis/test_network.py b/packages/python/goatlib/tests/unit/analysis/test_network.py
index a0d7e6a4f..f51ccda92 100644
--- a/packages/python/goatlib/tests/unit/analysis/test_network.py
+++ b/packages/python/goatlib/tests/unit/analysis/test_network.py
@@ -5,6 +5,7 @@
 from goatlib.analysis.network.network_processor import (
     InMemoryNetworkProcessor,
 )
+from goatlib.routing.schemas.base import Coordinates
 
 logger = logging.getLogger(__name__)
 
@@ -13,6 +14,7 @@
 def processor(network_file: Path) -> InMemoryNetworkProcessor:
     """A pytest fixture that yields a processor within a context manager."""
     with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        proc.load_network()
         yield proc
     # Cleanup is handled automatically as the 'with' block exits
 
@@ -20,42 +22,71 @@ def processor(network_file: Path) -> InMemoryNetworkProcessor:
 # ------------ Test Cases ------------
 
 
-def test_network_operations(
+def test_network_loading(
     processor: InMemoryNetworkProcessor,
 ) -> None:
     """Tests chaining non-destructive operations and verifies intermediate results."""
-    base_table_name = processor.network_table_name
-    filtered = processor.apply_sql_query(
-        f"SELECT * FROM {base_table_name} WHERE length_m > 150"
-    )
+    with InMemoryNetworkProcessor(input_path=processor._db_path) as proc:
+        table_name = proc.load_network()
+
+        metadata = processor.network_metadata
+        assert metadata is not None
+
+        stats = processor.get_network_stats()
+        assert stats["edge_count"] > 0
+        assert stats["total_length_m"] > 0.0
+        logger.info(
+            f"Network table '{table_name}' has {stats['edge_count']} edges, total length {stats['total_length_m']:.1f}m"
+        )
 
-    # 2. Use the result of the previous step ('filtered') directly in the next query
-    #    The 'base_table' argument is no longer needed.
-    transformed = processor.apply_sql_query(
-        f"SELECT *, length_m * 1.1 as adjusted_length FROM {filtered}"
-    )
 
-    # 3. Use the result of the previous step ('transformed') directly in the next query
-    summary = processor.apply_sql_query(
-        f"SELECT COUNT(*) as total_edges FROM {transformed}"
+def test_network_loading_with_point(
+    processor: InMemoryNetworkProcessor,
+) -> None:
+    """Tests chaining non-destructive operations and verifies intermediate results."""
+    with InMemoryNetworkProcessor(input_path=processor._db_path) as proc:
+        table_name = proc.load_network(
+            center=Coordinates(lat=48.137154, lon=11.576124),
+            buffer_radius=1000.0,
+            travel_time_minutes=15.0,
+            speed_kmh=5.0,
+        )
+    cut_stats = processor.get_network_stats(table_name)
+    assert cut_stats["edge_count"] > 0
+    assert cut_stats["total_length_m"] > 0.0
+    logger.info(
+        f"Cut network table '{table_name}' has {cut_stats['edge_count']} edges, total length {cut_stats['total_length_m']:.1f}m"
     )
 
-    filtered_stats = processor.get_network_stats(filtered)
-    transformed_stats = processor.get_network_stats(transformed)
-    summary_count = processor.con.execute(
-        f"SELECT total_edges FROM {summary}"
-    ).fetchone()[0]
+    output_path = "/app/packages/python/goatlib/tests/data/network/test.parquet"
+    # save table name for confirmation
+    processor.save_network(table_name, output_path)
 
-    # Assert that intermediate tables still exist and are correct
-    assert filtered_stats["edge_count"] > 0
-    assert transformed_stats["edge_count"] == filtered_stats["edge_count"]
-    assert summary_count == transformed_stats["edge_count"]
+
+def test_split_with_subset(network_file: Path) -> None:
+    """Test splitting edge on a network subset without loading full network."""
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        # This loads only ~500m radius around the point, not the full 375k edges
+        split_table, split_meta = proc.split_edge_at_point_with_subset(
+            point=Coordinates(lat=48.137154, lon=11.576124),
+            network_buffer_radius=500.0,
+            max_search_radius=100.0,
+        )
+        tables = proc.get_available_tables()
+        logger.info(f"Available tables after split: {tables}")
+
+        stats = proc.get_network_stats(split_table)
+        assert stats["edge_count"] < 375164
+
+        # Verify the split worked
+        assert split_meta.raw_meta["split_operation"]["artificial_node_id"] is not None
+        logger.info(f"Split edge on subset: {split_meta.raw_meta['split_operation']}")
 
 
 def test_save_to_file(processor: InMemoryNetworkProcessor, data_root: Path) -> None:
     """Test saving a table to a parquet file."""
     output_file = data_root / "network" / "network_output.parquet"
-    processor.save_table(processor.network_table_name, str(output_file))
+    processor.save_network(processor.network_table_name, output_path=str(output_file))
 
     # Verify the file was created
     assert output_file.exists()
@@ -64,13 +95,14 @@ def test_save_to_file(processor: InMemoryNetworkProcessor, data_root: Path) -> N
 
 def test_save_to_tmp(processor: InMemoryNetworkProcessor) -> None:
     """Test saving a table to a temporary parquet file."""
-    tmp_file_path = processor.save_table(processor.network_table_name)
+    tmp_file_path = processor.save_network(processor.network_table_name)
     # Verify the file was created
     from pathlib import Path
 
     tmp_file = Path(tmp_file_path)
     assert tmp_file.exists()
     assert tmp_file.stat().st_size > 0
+    logger.info(f"Temporary network file created at: {tmp_file_path}")
 
 
 def test_network_is_wkb_format(processor: InMemoryNetworkProcessor) -> None:
@@ -90,77 +122,12 @@ def test_get_available_tables(
     """Test listing available tables in the in-memory database."""
     tables = processor.get_available_tables()
     assert isinstance(tables, list)
-    assert (
-        processor.network_table_name in tables
-    )  # At least the network table should be present
-
-
-def test_edge_split(
-    processor: InMemoryNetworkProcessor,
-) -> None:
-    """
-    Comprehensive test for split operation correctness:
-    - Network metrics are preserved (length, edge count +1)
-    - Topology is correct (original edge removed, 2 new edges added)
-    - New edges have correct naming and connectivity
-    """
-    original_stats = processor.get_network_stats()
-    original_table_name = processor.network_table_name
-
-    split_table, split_meta = processor.split_edge_at_point(
-        latitude=48.13, longitude=11.58
-    )
+    assert processor.network_table_name in tables
+    logger.info(f"Network table: {processor.network_table_name}")
+    logger.info(f"Available tables: {tables}")
 
-    # Extract split info from metadata
-    split_info = split_meta.raw_meta["split_operation"]
-    split_stats = processor.get_network_stats(split_table)
-    original_edge_id = split_info["original_edge_split"]
-    new_node_id = split_info["artificial_node_id"]
 
-    # 1. Test Network Metrics Invariance
-    assert split_stats["edge_count"] == original_stats["edge_count"] + 1
-    assert abs(split_stats["total_length_m"] - original_stats["total_length_m"]) < 1.0
-    assert split_stats["avg_length_m"] < original_stats["avg_length_m"]
-
-    # 2. Test Original Edge Removal
-    original_edge_count = processor.con.execute(
-        f"SELECT COUNT(*) FROM {split_table} WHERE edge_id = '{original_edge_id}'"
-    ).fetchone()[0]
-    assert original_edge_count == 0
-
-    # 3. Test New Edge Creation and Naming
-    split_edges = processor.con.execute(f"""
-        SELECT edge_id, source, target FROM {split_table}
-        WHERE edge_id LIKE '{original_edge_id}_part_%' ORDER BY edge_id
-    """).fetchall()
-
-    assert len(split_edges) == 2
-    edge_a, edge_b = split_edges
-
-    # Check naming pattern
-    assert edge_a[0] == f"{original_edge_id}_part_a"
-    assert edge_b[0] == f"{original_edge_id}_part_b"
-
-    # Check connectivity topology
-    assert edge_a[2] == new_node_id  # target of part_a
-    assert edge_b[1] == new_node_id  # source of part_b
-
-    # 4. Test Edge Set Differences (verify exactly what changed)
-    removed_edges = processor.con.execute(f"""
-        SELECT edge_id FROM {original_table_name}
-        EXCEPT SELECT edge_id FROM {split_table}
-    """).fetchall()
-    assert len(removed_edges) == 1
-    assert str(removed_edges[0][0]) == str(original_edge_id)
-
-    added_edges = processor.con.execute(f"""
-        SELECT edge_id FROM {split_table}
-        EXCEPT SELECT edge_id FROM {original_table_name}
-    """).fetchall()
-    added_edge_ids = {row[0] for row in added_edges}
-    assert len(added_edge_ids) == 2
-    assert f"{original_edge_id}_part_a" in added_edge_ids
-    assert f"{original_edge_id}_part_b" in added_edge_ids
+# `------------ Complex Operation Tests ------------
 
 
 def test_interpolate_long_edges(processor: InMemoryNetworkProcessor) -> None:
@@ -170,7 +137,7 @@ def test_interpolate_long_edges(processor: InMemoryNetworkProcessor) -> None:
 
     # Find a reasonable threshold - use 75th percentile of edge lengths
     edge_lengths = processor.con.execute(f"""
-        SELECT length_m FROM {processor.network_table_name} 
+        SELECT length_m FROM {processor.network_table_name}
         ORDER BY length_m DESC
     """).fetchall()
 
@@ -238,32 +205,3 @@ def test_interpolate_long_edges(processor: InMemoryNetworkProcessor) -> None:
     logger.info(f"  New intermediate nodes: {info['new_intermediate_nodes']}")
     logger.info(f"  Max edge length threshold: {max_length:.1f}m")
     logger.info(f"  Processing time: {info['processing_time_seconds']:.2f}s")
-
-
-def test_concurrent_access(network_file: str) -> None:
-    """Test that multiple processors can be created and used concurrently safely."""
-    import concurrent.futures
-
-    from goatlib.analysis.network.network_processor import (
-        InMemoryNetworkProcessor,
-    )
-
-    def create_processor_and_get_stats() -> dict:
-        # Each thread gets its own processor instance with its own connection
-        with InMemoryNetworkProcessor(str(network_file)) as proc:
-            return proc.get_network_stats()
-
-    # Use a smaller number of workers to avoid resource exhaustion
-    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
-        futures = [executor.submit(create_processor_and_get_stats) for _ in range(3)]
-        results = [f.result() for f in concurrent.futures.as_completed(futures)]
-
-    # Verify all processors got consistent results
-    for stats in results:
-        assert stats["edge_count"] > 0
-
-    # All results should be identical since they're loading the same file
-    edge_counts = [stats["edge_count"] for stats in results]
-    assert (
-        len(set(edge_counts)) == 1
-    ), "All processors should report the same edge count"

From bc7a701e68d2cea348b47e51744f4bc2939e112c Mon Sep 17 00:00:00 2001
From: 96hoshi <marta.locascio@plan4better.de>
Date: Fri, 12 Dec 2025 16:25:01 +0000
Subject: [PATCH 06/11] fix:  improved split and interpolation functions
 timings

---
 .../analysis/network/network_processor.py     | 562 +++++++++---------
 .../benchmark_network_memory_usage.py         | 238 ++++++--
 .../integration/network/test_interpolation.py | 273 +++++++++
 .../network/test_network_preprocessing.py     | 343 ++++++++---
 .../tests/unit/analysis/test_network.py       | 231 ++++---
 5 files changed, 1133 insertions(+), 514 deletions(-)
 create mode 100644 packages/python/goatlib/tests/integration/network/test_interpolation.py

diff --git a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
index 295e7ae85..78bed25ea 100644
--- a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
+++ b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
@@ -1,12 +1,15 @@
 import logging
-import uuid
+import math
 import time
-from typing import Any, Dict, Tuple
+import uuid
+from typing import Any, Dict, Set
 
 from goatlib.analysis.core.base import AnalysisTool
 from goatlib.io.utils import Metadata
 from goatlib.routing.schemas.base import Coordinates
 
+SPLIT_EPSILON = 1e-6  # Configurable threshold
+
 logger = logging.getLogger(__name__)
 
 # from .super I have only: cleanup, init and import_input
@@ -14,35 +17,30 @@
 
 class InMemoryNetworkProcessor(AnalysisTool):
     """
-    High-performance in-memory network processor for routing.
+    In-memory network processor for routing.
     """
 
     def __init__(self, input_path: str) -> None:
-        """Initializes the processor. Requires network parameters to be valid."""
         super().__init__(db_path=input_path)
         self._is_loaded = False
         self._network_table_name: str
         self._meta: Metadata
+        self._created_tables: Set[str] = set()  # Track tables we create
+        self._original_tables: Set[str] = set()  # Tables that existed at init
 
     def __enter__(self) -> "InMemoryNetworkProcessor":
-        """Enters the context, loading the network and returning the processor instance."""
-        # Don't load network yet - wait for user to call create_buffered_subset
-        # This allows working with only a subset of the network for performance
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb) -> None:
-        """Exits the context, automatically cleaning up all database resources."""
         super().cleanup()
 
     @property
     def network_table_name(self) -> str:
-        """Get the name of the loaded network table."""
         self._ensure_loaded()
         return self._network_table_name
 
     @property
     def network_metadata(self) -> Metadata:
-        """Get metadata about the loaded network."""
         self._ensure_loaded()
         return self._meta
 
@@ -51,6 +49,19 @@ def _ensure_loaded(self) -> None:
         if not self._is_loaded:
             raise RuntimeError("Network not loaded. Call load_network() first.")
 
+    def _get_all_tables_safe(self) -> list[str]:
+        """Safely get all table names."""
+        try:
+            result = self.con.execute("""
+                SELECT table_name 
+                FROM information_schema.tables 
+                WHERE table_schema = 'main'
+                ORDER BY table_name
+            """).fetchall()
+            return [row[0] for row in result] if result else []
+        except:
+            return []
+
     def get_network_stats(self, table_name: str = None) -> Dict[str, Any]:
         """Get basic statistics about the network.
 
@@ -77,9 +88,10 @@ def get_network_stats(self, table_name: str = None) -> Dict[str, Any]:
             "max_length_m": float(result[4]) if result[4] else 0,
         }
 
-    def get_available_tables(self) -> list[str]:
-        result = self.con.execute("SHOW TABLES").fetchall()
-        return [row[0] for row in result]
+    # def _get_available_tables(self) -> list[str]:
+    #     """Returns a list of available table names in the DuckDB database. used for testing purposes."""
+    #     result = self.con.execute("SHOW TABLES").fetchall()
+    #     return [row[0] for row in result]
 
     def apply_sql_query(
         self, sql_query: str, result_table: str = "query_result"
@@ -113,7 +125,6 @@ def load_network(
         logger.info(f"Network loaded into table: {self._network_table_name}")
 
         # Validate required columns exist
-        # TODO check if this is made in import_input
         if not self._meta.geometry_column:
             raise ValueError("Network file must have a geometry column")
 
@@ -130,45 +141,36 @@ def load_network(
             buffer_distance = travel_time_minutes * (speed_kmh * 1000 / 60)
 
         # Convert meters to degrees (approximate at the given latitude)
-        # DuckDB spatial doesn't have ST_DWithin_Sphere, so we convert to degrees
-        import math
 
         lat_rad = math.radians(center.lat)
         meters_per_degree_lat = 111320  # roughly constant
         meters_per_degree_lon = 111320 * math.cos(lat_rad)
-        # Use average for simplicity
         buffer_degrees = buffer_distance / (
             (meters_per_degree_lat + meters_per_degree_lon) / 2
         )
 
         logger.info(
-            f"Creating buffered network subset with buffer distance: {buffer_distance:.2f} meters "
-            f"(~{buffer_degrees:.6f} degrees)"
+            f"Creating buffered network subset with buffer distance: {buffer_distance:.2f} m"
         )
 
         # Create buffered network
         subset_table_name = f"routing_network_{uuid.uuid4().hex[:8]}"
-
+        # circular buffer around point
         subset_query = f"""
             CREATE TABLE {subset_table_name} AS
             SELECT t.*
             FROM {self._network_table_name} t
-            WHERE ST_Intersects(
+            WHERE ST_DWithin(
                 t.{self._meta.geometry_column},
-                ST_Buffer(
-                    ST_Point({center.lon}, {center.lat}),
-                    {buffer_degrees}
-                )
+                ST_MakePoint({center.lon}, {center.lat}), {buffer_degrees}
             )
             """
 
-        import time
-
         start = time.time()
         self.con.execute(subset_query)
         elapsed = time.time() - start
 
-        logger.info(f"Network subset created in {elapsed:.3f} seconds")
+        logger.info(f"Network subset created in {round(elapsed * 1000, 1)} ms")
         self._is_loaded = True
 
         return subset_table_name
@@ -177,8 +179,8 @@ def load_network(
     def split_edge_at_point_with_subset(
         self,
         point: Coordinates,
-        network_buffer_radius: float = 500.0,
-        max_search_radius: float = 20.0,
+        network_buffer_radius: float = 1000.0,
+        max_search_radius_m: float = 20.0,
     ) -> tuple[str, Metadata]:
         """
         Loads a network subset around a point and splits the nearest edge.
@@ -187,10 +189,8 @@ def split_edge_at_point_with_subset(
 
         Args:
             point: Coordinates where to split
-            network_buffer_radius: Radius in meters to load network around the point (default: 500m)
-            max_search_radius: Maximum search radius in meters for finding closest edge (default: 200m)
-            include_stats: Whether to include edge count statistics
-
+            network_buffer_radius: Radius in meters to load network around the point
+            max_search_radius_m: Maximum search radius in meters for finding closest edge
         Returns:
             Tuple of (table_name, metadata) with split operation details
         """
@@ -206,292 +206,316 @@ def split_edge_at_point_with_subset(
         return self.split_edge_at_point(
             point=point,
             source_table=subset_table,
-            max_search_radius=max_search_radius,
+            max_search_radius_m=max_search_radius_m,
         )
 
     def split_edge_at_point(
         self,
         point: Coordinates,
         source_table: str = None,
-        max_search_radius: float = 100.0,
+        max_search_radius_m: float = 100.0,
     ) -> tuple[str, Metadata]:
         """
         Finds the closest edge to a point, splits it, and creates a new network table.
 
         Args:
-            latitude: Latitude of the split point
-            longitude: Longitude of the split point
-            base_table: Source table name (defaults to main network table)
-            max_search_radius: Maximum search radius in meters
-            include_stats: Whether to include edge count statistics (default: True)
+            point: Coordinates where to start the route
+            source_table: Source table name (defaults to main network table)
+            max_search_radius_m: Maximum search radius in meters
 
         Returns:
             Tuple of (table_name, metadata) with split operation details in raw_meta
         """
-        split_table_name = f"split_network_{uuid.uuid4().hex[:8]}"
+        # Generate unique IDs
         new_node_id = f"split_node_{uuid.uuid4().hex[:8]}"
+        split_table_name = f"split_network_{uuid.uuid4().hex[:8]}"
+
+        # Set source table if not provided
+        if source_table is None:
+            source_table = self._network_table_name
+
+        # Prepare geometry references
         point_geom = f"ST_Point({point.lon}, {point.lat})"
         geom_col = self._meta.geometry_column
 
-        # First, find the closest edge using bbox optimization
-        info_query = f"""
-        WITH search_bbox AS (
-            SELECT ST_Envelope(
-                ST_Buffer({point_geom}, {max_search_radius})
-            ) AS bbox
-        ), candidate_edges AS (
-            SELECT *
-            FROM {source_table}, search_bbox
-            WHERE ST_Intersects({geom_col}, search_bbox.bbox)
-        ), closest_edge AS (
+        # Convert meters to degrees for spatial search
+        # Approximation: 1 degree ≈ 111.32 km at equator
+        search_radius_deg = max_search_radius_m / 111320.0
+
+        # QUERY 1: Find closest edge with all needed info
+        find_query = f"""
+        WITH closest AS (
             SELECT
                 edge_id,
-                ST_Distance({geom_col}, {point_geom}) AS distance,
-                ST_LineLocatePoint({geom_col}, {point_geom}) AS split_fraction,
-                {geom_col}
-            FROM candidate_edges
-            ORDER BY distance ASC
+                source,
+                target,
+                length_m,
+                cost,
+                {geom_col},
+                ST_Distance({geom_col}, {point_geom}) as dist_deg,
+                ST_LineLocatePoint({geom_col}, {point_geom}) as frac
+            FROM {source_table}
+            WHERE ST_DWithin({geom_col}, {point_geom}, {search_radius_deg})
+            ORDER BY dist_deg
             LIMIT 1
-        ), split_point_calc AS (
-            SELECT
-                edge_id,
-                split_fraction,
-                distance,
-                ST_X(ST_LineInterpolatePoint({geom_col}, split_fraction)) AS split_lon,
-                ST_Y(ST_LineInterpolatePoint({geom_col}, split_fraction)) AS split_lat
-            FROM closest_edge
         )
         SELECT
-            edge_id,
-            split_fraction,
-            split_lon,
-            split_lat,
-            distance
-        FROM split_point_calc;
+            *,
+            CASE WHEN frac BETWEEN 0.001 AND 0.999 THEN 1 ELSE 0 END as valid_split,
+            ST_X(ST_LineInterpolatePoint({geom_col}, frac)) as split_lon,
+            ST_Y(ST_LineInterpolatePoint({geom_col}, frac)) as split_lat
+        FROM closest;
         """
+
+        # Execute find query
         find_start = time.time()
-        info_res = self.con.execute(info_query).fetchone()
+        result = self.con.execute(find_query).fetchone()
+        find_elapsed = time.time() - find_start
 
-        # Check if any edge was found
-        if not info_res or info_res[0] is None:
+        if not result:
             raise ValueError(
-                "No edges found. Try increasing max_search_radius or check if the point is near the network."
+                f"No edge found within {max_search_radius_m}m of point ({point.lat}, {point.lon})"
             )
-        find_elapsed = time.time() - find_start
-        logger.info(f"Found closest edge in {find_elapsed:.3f}s")
 
-        # Now create the split table using the found edge
-        original_edge_id, split_fraction, split_lon, split_lat, distance = info_res
+        if result[-3] == 0:  # valid_split column
+            raise ValueError(
+                f"Edge found but split fraction {result[7]:.6f} is too close to endpoint"
+            )
 
+        # Extract values from result
+        original_edge_id = result[0]
+        source_node = result[1]
+        target_node = result[2]
+        length_m = result[3]
+        cost_val = result[4]
+        dist_deg = result[6]
+        split_fraction = result[7]
+        split_lon = result[9]
+        split_lat = result[10]
+
+        # Convert distance to meters
+        distance_m = dist_deg * 111320.0
+
+        # QUERY 2: Split the edge efficiently
         split_query = f"""
         CREATE TABLE {split_table_name} AS
-        WITH target_edge AS (
-            -- Select the specific edge we found
-            SELECT * FROM {source_table}
-            WHERE edge_id = '{original_edge_id}'
-        ),
-        new_split_parts AS (
-            -- Create two new edge segments from the original edge at the split point
-            -- Part A: from original source to new split node
-            SELECT
-                edge_id || '_part_a' as edge_id,
-                source,
-                '{new_node_id}' as target,
-                length_m * {split_fraction} AS length_m,
-                cost * {split_fraction} AS cost,
-                ST_LineSubstring({geom_col}, 0.0, {split_fraction}) as {geom_col}
-            FROM target_edge
 
-            UNION ALL
+        -- All edges except the one being split
+        SELECT *
+        FROM {source_table}
+        WHERE edge_id != '{original_edge_id}'
+
+        UNION ALL
+
+        -- Split into two parts: Source → New Node
+        SELECT
+            '{original_edge_id}_A' as edge_id,
+            source,
+            '{new_node_id}' as target,
+            ROUND(length_m * {split_fraction}, 3) as length_m,
+            ROUND(cost * {split_fraction}, 3) as cost,
+            ST_LineSubstring({geom_col}, 0.0, {split_fraction}) as {geom_col}
+        FROM {source_table}
+        WHERE edge_id = '{original_edge_id}'
 
-            -- Part B: from new split node to original target
-            SELECT
-                edge_id || '_part_b' as edge_id,
-                '{new_node_id}' as source,
-                target,
-                length_m * (1.0 - {split_fraction}) AS length_m,
-                cost * (1.0 - {split_fraction}) AS cost,
-                ST_LineSubstring({geom_col}, {split_fraction}, 1.0) as {geom_col}
-            FROM target_edge
-        )
-        -- Combine all unchanged edges with the new split edge parts
-        SELECT * FROM {source_table}
-        WHERE edge_id <> '{original_edge_id}'
         UNION ALL
-        SELECT * FROM new_split_parts;
+
+        -- Split into two parts: New Node → Target
+        SELECT
+            '{original_edge_id}_B' as edge_id,
+            '{new_node_id}' as source,
+            target,
+            ROUND(length_m * (1.0 - {split_fraction}), 3) as length_m,
+            ROUND(cost * (1.0 - {split_fraction}), 3) as cost,
+            ST_LineSubstring({geom_col}, {split_fraction}, 1.0) as {geom_col}
+        FROM {source_table}
+        WHERE edge_id = '{original_edge_id}';
         """
 
+        # Execute split query
         split_start = time.time()
         self.con.execute(split_query)
         split_elapsed = time.time() - split_start
-        logger.info(f"Created split table in {split_elapsed:.3f}s")
 
         logger.info(
-            f"Original edge '{original_edge_id}' split at fraction {split_fraction:.6f} "
-            f"({distance:.2f}m from point) into new node '{new_node_id}'"
+            f"Edge '{original_edge_id}' split at {split_fraction:.3%} "
+            f"(~{distance_m:.1f}m from request) → Node '{new_node_id}' "
+            f"[Table: {split_table_name}] in {find_elapsed + split_elapsed:.3f}s"
         )
-        # Create metadata for the split table (copy from original)
-        split_meta = Metadata(geometry_column=self._meta.geometry_column, raw_meta={})
-
-        # Add split operation details to metadata
-        split_operation_info = {
-            "operation": "edge_split",
-            "method": "bbox_optimization",
-            "artificial_node_id": new_node_id,
-            "original_edge_split": original_edge_id,
-            "split_fraction": split_fraction,
-            "distance_to_edge": distance,
-            "max_search_radius": max_search_radius,
-            "new_node_coords": {
-                "lon": split_lon,
-                "lat": split_lat,
-            },
-        }
 
-        split_meta.raw_meta["split_operation"] = split_operation_info
+        # 2. METADATA
+        split_meta = Metadata(
+            geometry_column=self._meta.geometry_column,
+            raw_meta={
+                "source_table": source_table,
+                "split_operation": {
+                    "artificial_node_id": new_node_id,
+                    "original_edge": original_edge_id,
+                    "split_position": {
+                        "fraction": split_fraction,
+                        "request_point": {"lat": point.lat, "lon": point.lon},
+                        "actual_point": {"lat": split_lat, "lon": split_lon},
+                    },
+                    "edge_properties": {
+                        "original_length_m": length_m,
+                        "part_a_length_m": round(length_m * split_fraction, 3),
+                        "part_b_length_m": round(length_m * (1 - split_fraction), 3),
+                        "original_cost": cost_val,
+                        "source_node": source_node,
+                        "target_node": target_node,
+                    },
+                    "search_params": {
+                        "max_radius_m": max_search_radius_m,
+                        "search_radius_deg": search_radius_deg,
+                        "actual_distance_m": round(distance_m, 3),
+                    },
+                    "performance": {
+                        "find_query_ms": round(find_elapsed * 1000, 1),
+                        "split_query_ms": round(split_elapsed * 1000, 1),
+                        "total_ms": round((find_elapsed + split_elapsed) * 1000, 1),
+                    },
+                },
+            },
+        )
 
-        # Warning for edge cases
-        if not (1e-9 < split_fraction < 1.0 - 1e-9):
+        # 3. VALIDATION WARNINGS
+        if split_fraction < SPLIT_EPSILON:
             logger.warning(
-                f"Split point is at or very near an existing node (fraction={split_fraction:.6f}). "
-                "The original edge was effectively replaced, not split into two new segments."
+                f"Split at start of edge (fraction={split_fraction:.6f}). "
+                f"Consider using existing node '{source_node}' instead of '{new_node_id}'."
+            )
+        elif split_fraction > 1.0 - SPLIT_EPSILON:
+            logger.warning(
+                f"Split at end of edge (fraction={split_fraction:.6f}). "
+                f"Consider using existing node '{target_node}' instead of '{new_node_id}'."
             )
 
         return split_table_name, split_meta
 
-    # def interpolate_long_edges(
-    #     self,
-    #     max_edge_length: float,
-    #     base_table: str = None,
-    #     interpolation_distance: float = None,
-    # ) -> tuple[str, Metadata]:
-    #     """
-    #     Interpolate nodes along edges that are longer than the specified threshold.
-    #     Creates actual intermediate nodes with coordinates and splits edges accordingly.
-
-    #     Args:
-    #         max_edge_length: Maximum allowed edge length in meters
-    #         base_table: Table to process (defaults to main network table)
-    #         interpolation_distance: Distance between interpolated points (defaults to max_edge_length/2)
-
-    #     Returns:
-    #         Tuple of (table_name, metadata) where metadata contains table schema
-    #         and interpolation details in raw_meta
-    #     """
-    #     import time
-
-    #     start_time = time.time()
-    #     self._ensure_loaded()
-    #     source_table = base_table or self.network_table_name
-    #     interpolated_table = self._generate_table_name("interpolated_network")
-
-    #     # Default interpolation distance
-    #     if interpolation_distance is None:
-    #         interpolation_distance = max_edge_length / 2
-
-    #     # Use metadata geometry column for dynamic column handling
-    #     geom_column = self.meta.geometry_column
-
-    #     # Combined query: create table and get statistics in one go
-    #     interpolation_query = f"""
-    #     CREATE TABLE {interpolated_table} AS
-    #     WITH original_stats AS (
-    #         SELECT
-    #             COUNT(*) as original_edges,
-    #             COUNT(*) FILTER (WHERE length_m > {max_edge_length}) as long_edges_count
-    #         FROM {source_table}
-    #     ),
-    #     long_edges AS (
-    #         -- Identify edges that need interpolation and calculate segments needed
-    #         SELECT *,
-    #                CAST(CEIL(length_m / {interpolation_distance}) AS INTEGER) as num_segments
-    #         FROM {source_table}
-    #         WHERE length_m > {max_edge_length}
-    #     ),
-    #     interpolated_segments AS (
-    #         -- Generate new edges with intermediate nodes
-    #         SELECT
-    #             edge_id || '_seg_' || CAST(segment_id AS VARCHAR) as edge_id,
-    #             CASE
-    #                 WHEN segment_id = 1 THEN CAST(source AS VARCHAR)
-    #                 ELSE 'interp_' || edge_id || '_' || CAST((segment_id - 1) AS VARCHAR)
-    #             END as source,
-    #             CASE
-    #                 WHEN segment_id = num_segments THEN CAST(target AS VARCHAR)
-    #                 ELSE 'interp_' || edge_id || '_' || CAST(segment_id AS VARCHAR)
-    #             END as target,
-    #             length_m / num_segments as length_m,
-    #             cost / num_segments as cost,
-    #             ST_LineSubstring(
-    #                 {geom_column},
-    #                 (segment_id - 1.0) / num_segments,
-    #                 segment_id / num_segments
-    #             ) as {geom_column}
-    #         FROM long_edges
-    #         CROSS JOIN generate_series(1, num_segments) as t(segment_id)
-    #     )
-    #     -- Combine short edges (unchanged) with interpolated segments
-    #     SELECT edge_id, source, target, length_m, cost, {geom_column}
-    #     FROM {source_table}
-    #     WHERE length_m <= {max_edge_length}
-
-    #     UNION ALL
-
-    #     SELECT edge_id, source, target, length_m, cost, {geom_column}
-    #     FROM interpolated_segments
-    #     ORDER BY edge_id;
-    #     """
-
-    #     self.con.execute(interpolation_query)
-    #     processing_time = time.time() - start_time
-
-    #     # Get statistics in single optimized query
-    #     stats_query = f"""
-    #     WITH original_stats AS (
-    #         SELECT
-    #             COUNT(*) as original_edges,
-    #             COUNT(*) FILTER (WHERE length_m > {max_edge_length}) as long_edges_count
-    #         FROM {source_table}
-    #     ),
-    #     new_stats AS (
-    #         SELECT COUNT(*) as new_edges FROM {interpolated_table}
-    #     ),
-    #     node_stats AS (
-    #         SELECT
-    #             COUNT(DISTINCT source) + COUNT(DISTINCT target) as total_nodes,
-    #             COUNT(DISTINCT source) FILTER (WHERE source LIKE 'interp_%') +
-    #             COUNT(DISTINCT target) FILTER (WHERE target LIKE 'interp_%') as new_nodes
-    #         FROM {interpolated_table}
-    #     )
-    #     SELECT
-    #         o.original_edges,
-    #         o.long_edges_count,
-    #         n.new_edges,
-    #         ns.new_nodes,
-    #         ns.total_nodes
-    #     FROM original_stats o, new_stats n, node_stats ns;
-    #     """
-
-    #     stats_result = self.con.execute(stats_query).fetchone()
-
-    #     # Create metadata for the interpolated table using fast path
-    #     interpolated_meta = self._create_metadata_from_template(interpolated_table)
-
-    #     # Embed interpolation details in raw_meta
-    #     interpolated_meta.raw_meta = interpolated_meta.raw_meta or {}
-    #     interpolated_meta.raw_meta["interpolation_operation"] = {
-    #         "original_edge_count": stats_result[0],
-    #         "long_edges_processed": stats_result[1],
-    #         "final_edge_count": stats_result[2],
-    #         "new_intermediate_nodes": stats_result[3],
-    #         "total_nodes": stats_result[4],
-    #         "edges_added": stats_result[2] - stats_result[0],
-    #         "max_edge_length_threshold": max_edge_length,
-    #         "interpolation_distance": interpolation_distance,
-    #         "processing_time_seconds": processing_time,
-    #     }
-
-    #     return interpolated_table, interpolated_meta
+    def interpolate_long_edges(
+        self,
+        max_edge_length: float,
+        base_table: str = None,
+        interpolation_distance: float = None,
+        include_stats: bool = False,
+    ) -> tuple[str, Metadata]:
+        """
+        Main function - creates interpolated table.
+        Stats are optional for performance.
+        """
+        source_table = base_table or self.network_table_name
+        interpolated_table = f"interpolated_network_{uuid.uuid4().hex[:8]}"
+
+        if interpolation_distance is None:
+            interpolation_distance = max_edge_length / 2
+
+        query = f"""
+        CREATE TABLE {interpolated_table} AS
+        WITH long_edges AS (
+            SELECT *,
+                CAST(CEIL(length_m / {interpolation_distance}) AS INTEGER) as num_segments
+            FROM {source_table}
+            WHERE length_m > {max_edge_length}
+        ),
+        interpolated_segments AS (
+            SELECT
+                edge_id || '_seg_' || CAST(segment_id AS VARCHAR) as edge_id,
+                CASE
+                    WHEN segment_id = 1 THEN CAST(source AS VARCHAR)
+                    ELSE 'interp_' || edge_id || '_' || CAST((segment_id - 1) AS VARCHAR)
+                END as source,
+                CASE
+                    WHEN segment_id = num_segments THEN CAST(target AS VARCHAR)
+                    ELSE 'interp_' || edge_id || '_' || CAST(segment_id AS VARCHAR)
+                END as target,
+                length_m / num_segments as length_m,
+                cost / num_segments as cost,
+                ST_LineSubstring(
+                    {self._meta.geometry_column},
+                    (segment_id - 1.0) / num_segments,
+                    segment_id / num_segments
+                ) as {self._meta.geometry_column}
+            FROM long_edges
+            CROSS JOIN generate_series(1, num_segments) as t(segment_id)
+        )
+        SELECT edge_id, source, target, length_m, cost, {self._meta.geometry_column}
+        FROM {source_table}
+        WHERE length_m <= {max_edge_length}
+        UNION ALL
+        SELECT edge_id, source, target, length_m, cost, {self._meta.geometry_column}
+        FROM interpolated_segments
+        ORDER BY edge_id;
+        """
+        start_time = time.time()
+        self.con.execute(query)
+        processing_time = time.time() - start_time
+
+        logger.info(
+            f"MAIN Interpolated network created: {interpolated_table} "
+            f"in {processing_time:.3f}s"
+        )
+
+        # Create metadata
+        meta = Metadata(
+            geometry_column=self._meta.geometry_column,
+            raw_meta={
+                "interpolation_operation": {
+                    "table_name": interpolated_table,
+                    "source_table": source_table,
+                    "interpolation_params": {
+                        "max_edge_length": max_edge_length,
+                        "interpolation_distance": interpolation_distance,
+                    },
+                }
+            },
+        )
+        if include_stats:
+            stats = self._get_interpolation_stats(table_name=interpolated_table)
+            meta.raw_meta["interpolation_operation"].update(stats)
+
+        return interpolated_table, meta
+
+    def _get_interpolation_stats(
+        self,
+        table_name: str,
+    ) -> Dict[str, Any]:
+        """Get statistics about the interpolation operation."""
+        stats_query = f"""
+        WITH stats AS (
+            SELECT
+                COUNT(*) as total_edges,
+                COUNT(*) FILTER (WHERE edge_id LIKE '%_seg_%') as segments_created,
+                MAX(length_m) as max_segment_length,
+                SUM(length_m) as total_length
+            FROM {table_name}
+        ),
+        node_stats AS (
+            SELECT
+                COUNT(DISTINCT source) + COUNT(DISTINCT target) as total_nodes,
+                COUNT(DISTINCT source) FILTER (WHERE source LIKE 'interp_%') +
+                COUNT(DISTINCT target) FILTER (WHERE target LIKE 'interp_%') as new_nodes
+            FROM {table_name}
+        )
+        SELECT
+            s.total_edges,
+            s.segments_created,
+            s.max_segment_length,
+            s.total_length,
+            ns.new_nodes,
+            ns.total_nodes
+        FROM stats s, node_stats ns;
+        """
+
+        stats_result = self.con.execute(stats_query).fetchone()
+
+        return {
+            "final_edge_count": stats_result[0],
+            "segments_created": stats_result[1],
+            "max_segment_length_m": round(stats_result[2], 2),
+            "total_length_m": round(stats_result[3], 2),
+            "new_intermediate_nodes": stats_result[4],
+            "total_nodes": stats_result[5],
+        }
 
     # File I/O Methods
     def save_network(
diff --git a/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py b/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
index 8f7c9a841..ebe155919 100644
--- a/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
+++ b/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
@@ -12,6 +12,7 @@
 
 import pytest
 from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
+from goatlib.routing.schemas.base import Coordinates
 
 logging.basicConfig(
     level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
@@ -49,7 +50,7 @@ def run_lightweight_benchmark(network_path: str | None = None) -> None:
         return
 
     print("=" * 80)
-    print("🚀 Lightweight Network Processor: Performance Benchmark (Original)")
+    print("🚀 Lightweight Network Processor: Performance Benchmark")
     print("=" * 80)
 
     gc.collect()
@@ -63,35 +64,35 @@ def run_lightweight_benchmark(network_path: str | None = None) -> None:
 
     with InMemoryNetworkProcessor(network_path) as proc:
         stages.append(("After Loading", get_memory_mb()))
-        stats = proc.get_network_stats()
-        original_table = proc.network_table_name
-
-        # Create a filtered network (matching original)
-        filtered_table = proc._generate_table_name("filtered_network")
-        proc.con.execute(f"""
-            CREATE TABLE {filtered_table} AS 
-            SELECT * FROM {original_table} WHERE length_m > 100
-        """)
-        stages.append(("After Filtering", get_memory_mb()))
-
-        # Test edge splitting only (matching original)
+
+        # Load network (replaces _generate_table_name)
+        center = Coordinates(lat=48.1351, lon=11.5820)
+        subset_table = proc.load_network(center=center, buffer_radius=2000)
+        stages.append(("After Subset Creation", get_memory_mb()))
+
+        stats = proc.get_network_stats(subset_table)
+
+        # Test edge splitting
         try:
+            split_point = Coordinates(lat=48.1370, lon=11.5760)
             split_table, split_meta = proc.split_edge_at_point(
-                latitude=48.13,
-                longitude=11.58,
-                # base_table=filtered_table,
+                point=split_point,
+                source_table=subset_table,
+                max_search_radius_m=100.0,
             )
             stages.append(("After Edge Split", get_memory_mb()))
+
+            # Verify split worked
+            split_stats = proc.get_network_stats(split_table)
+            assert split_stats["edge_count"] == stats["edge_count"] + 1
+
         except ValueError as e:
             print(f"Split operation failed: {e}")
             stages.append(("After Failed Split", get_memory_mb()))
 
-        # Cleanup intermediate (matching original)
-        stages.append(("After Intermediate Cleanup", get_memory_mb()))
-
     total_time_end = time.perf_counter()
     gc.collect()
-    stages.append(("Final (After Full Cleanup)", get_memory_mb()))
+    stages.append(("Final (After Context Exit)", get_memory_mb()))
 
     # Print all stages
     for stage_name, memory_data in stages:
@@ -103,6 +104,7 @@ def run_lightweight_benchmark(network_path: str | None = None) -> None:
     print("-" * 80)
     print("📊 Summary:")
     print(f"Total processing time: {total_duration:.3f} seconds")
+    print(f"Network size: {stats['edge_count']:,} edges")
     print(
         f"Peak Physical Memory (RSS) Increase: {peak_rss - baseline_memory['rss']:.1f} MB"
     )
@@ -112,7 +114,6 @@ def run_lightweight_benchmark(network_path: str | None = None) -> None:
 
 def run_full_benchmark(network_path: str | None = None):
     """Full benchmark including interpolation and advanced features."""
-    # Get network path from conftest fixture location if not provided
     if network_path is None:
         network_path = str(
             Path(__file__).parent.parent / "data" / "network" / "network.parquet"
@@ -123,7 +124,7 @@ def run_full_benchmark(network_path: str | None = None):
         return
 
     print("=" * 80)
-    print("🧠 Full Network Processor: Performance and Memory Benchmark")
+    print("🧠 Full Network Processor: Complete Workflow Benchmark")
     print("=" * 80)
 
     gc.collect()
@@ -137,41 +138,58 @@ def run_full_benchmark(network_path: str | None = None):
 
     with InMemoryNetworkProcessor(network_path) as proc:
         stages.append(("After Loading", get_memory_mb()))
-        stats = proc.get_network_stats()
-        original_table = proc.network_table_name
-
-        # Create a filtered network
-        filtered_table = proc._generate_table_name("filtered_network")
-        proc.con.execute(f"""
-            CREATE TABLE {filtered_table} AS 
-            SELECT * FROM {original_table} WHERE length_m > 100
-        """)
-        stages.append(("After Filtering", get_memory_mb()))
 
-        # Test edge splitting
-        try:
-            split_table, split_meta = proc.split_edge_at_point(
-                latitude=48.13,
-                longitude=11.58,
-                base_table=filtered_table,
-            )
-            stages.append(("After Edge Split", get_memory_mb()))
-        except ValueError as e:
-            print(f"Split operation failed: {e}")
-            stages.append(("After Failed Split", get_memory_mb()))
+        # 1. Load network subset
+        center = Coordinates(lat=48.1351, lon=11.5820)
+        subset_table = proc.load_network(center=center, buffer_radius=5000)
+        subset_stats = proc.get_network_stats(subset_table)
+        stages.append(("After Subset Creation", get_memory_mb()))
+        print(f"📊 Subset: {subset_stats['edge_count']:,} edges")
+
+        # 2. Split edge at point
+        split_point = Coordinates(lat=48.1370, lon=11.5760)
+        split_table, split_meta = proc.split_edge_at_point(
+            point=split_point,
+            source_table=subset_table,
+            max_search_radius_m=100.0,
+        )
+        split_stats = proc.get_network_stats(split_table)
+        stages.append(("After Edge Split", get_memory_mb()))
+        print(f"✂️  Split: {split_stats['edge_count']:,} edges (+1)")
+
+        # 3. Interpolate long edges
+        interp_table, interp_meta = proc.interpolate_long_edges(
+            max_edge_length=50.0,
+            base_table=split_table,
+            include_stats=True,
+        )
+        interp_stats = proc.get_network_stats(interp_table)
+        stages.append(("After Interpolation", get_memory_mb()))
+        print(f"📐 Interpolated: {interp_stats['edge_count']:,} edges")
+
+        # 4. Test split with subset (combined operation)
+        combined_table, combined_meta = proc.split_edge_at_point_with_subset(
+            point=Coordinates(lat=48.1360, lon=11.5770),
+            network_buffer_radius=1000.0,
+            max_search_radius_m=50.0,
+        )
+        stages.append(("After Combined Split", get_memory_mb()))
+
+        # 5. Test apply_sql_query
+        sql_table = proc.apply_sql_query(
+            sql_query=f"""
+            SELECT * 
+            FROM {interp_table} 
+            WHERE length_m > 30 
+            AND edge_id NOT LIKE '%_s%'
+            """,
+            result_table="filtered_long",
+        )
+        stages.append(("After SQL Query", get_memory_mb()))
 
-        # Test interpolation
-        try:
-            interp_table, interp_meta = proc.interpolate_long_edges(
-                max_edge_length=200.0, base_table=original_table
-            )
-            stages.append(("After Interpolation", get_memory_mb()))
-        except Exception as e:
-            print(f"Interpolation failed: {e}")
-            stages.append(("After Failed Interpolation", get_memory_mb()))
     total_time_end = time.perf_counter()
     gc.collect()
-    stages.append(("Final (After Full Cleanup)", get_memory_mb()))
+    stages.append(("Final (After Cleanup)", get_memory_mb()))
 
     # Print all stages
     for stage_name, memory_data in stages:
@@ -183,13 +201,79 @@ def run_full_benchmark(network_path: str | None = None):
     print("-" * 80)
     print("📊 Summary:")
     print(f"Total processing time: {total_duration:.3f} seconds")
+    print(f"Original subset: {subset_stats['edge_count']:,} edges")
+    print(f"Final interpolated: {interp_stats['edge_count']:,} edges")
+    print(
+        f"Edge increase: {interp_stats['edge_count'] - subset_stats['edge_count']:,} edges"
+    )
     print(
         f"Peak Physical Memory (RSS) Increase: {peak_rss - baseline_memory['rss']:.1f} MB"
     )
-    print(f"Processing Rate: {stats['edge_count'] / total_duration:,.0f} edges/second")
+    print(f"Operations/second: {5 / total_duration:.1f} ops/sec")  # 5 main operations
     print("=" * 80)
 
 
+def run_performance_stress_test(network_path: str | None = None):
+    """Stress test with multiple operations."""
+    if network_path is None:
+        network_path = str(
+            Path(__file__).parent.parent / "data" / "network" / "network.parquet"
+        )
+
+    if not (PSUTIL_AVAILABLE and Path(network_path).exists()):
+        print("psutil or network file not available. Aborting benchmark.")
+        return
+
+    print("=" * 80)
+    print("⚡ Network Processor: Stress Test (Multiple Operations)")
+    print("=" * 80)
+
+    gc.collect()
+    baseline_memory = get_memory_mb()
+
+    with InMemoryNetworkProcessor(network_path) as proc:
+        center = Coordinates(lat=48.1351, lon=11.5820)
+
+        # Create multiple subsets
+        tables = []
+        start = time.perf_counter()
+
+        for i in range(3):
+            # Vary buffer sizes
+            table = proc.load_network(center=center, buffer_radius=1000 + i * 2000)
+            tables.append(table)
+
+            # Split at slightly different points
+            split_point = Coordinates(
+                lat=48.1351 + (i * 0.001), lon=11.5820 + (i * 0.001)
+            )
+            split_table, _ = proc.split_edge_at_point(
+                point=split_point,
+                source_table=table,
+                max_search_radius_m=50.0,
+            )
+            tables.append(split_table)
+
+            # Interpolate with different thresholds
+            interp_table, _ = proc.interpolate_long_edges(
+                max_edge_length=30.0 + (i * 20),
+                base_table=split_table,
+                include_stats=False,
+            )
+            tables.append(interp_table)
+
+        end = time.perf_counter()
+
+        print(f"Created {len(tables)} tables in {end - start:.2f}s")
+        print(f"Average: {(end - start) / len(tables):.3f}s per table")
+
+        # Memory after many operations
+        current_memory = get_memory_mb()
+        print_memory("After Stress Test", current_memory, baseline_memory)
+
+    print("✅ Stress test completed - all tables should be cleaned up")
+
+
 # --- Pytest Version Using Conftest Fixture ---
 def test_benchmark_with_fixture(network_file: Path):
     """Pytest version of the benchmark that uses the conftest network_file fixture."""
@@ -199,11 +283,53 @@ def test_benchmark_with_fixture(network_file: Path):
     run_lightweight_benchmark(str(network_file))
 
 
+def test_full_benchmark_with_fixture(network_file: Path):
+    """Full benchmark test."""
+    if not PSUTIL_AVAILABLE:
+        pytest.skip("psutil not available for memory monitoring")
+
+    run_full_benchmark(str(network_file))
+
+
+def test_table_tracking_benchmark(network_file: Path):
+    """Test table tracking and cleanup."""
+    if not PSUTIL_AVAILABLE:
+        pytest.skip("psutil not available for memory monitoring")
+
+    # Get initial table count
+    with InMemoryNetworkProcessor(str(network_file)) as proc:
+        initial_tables = proc.get_application_tables()
+        print(f"Initial tables: {len(initial_tables)}")
+
+        # Create tables
+        center = Coordinates(lat=48.1351, lon=11.5820)
+        table1 = proc.load_network(center=center, buffer_radius=1000)
+        table2, _ = proc.split_edge_at_point(
+            point=center,
+            source_table=table1,
+            max_search_radius_m=100.0,
+        )
+
+        # Memory usage
+        mem = get_memory_mb()
+        print(f"Memory with 2 tables: {mem['rss']:.1f} MB RSS")
+
+    # After context exit, tables should be cleaned
+    # (Can't verify without new connection, but memory should drop)
+    final_mem = get_memory_mb()
+    print(f"Final memory after cleanup: {final_mem['rss']:.1f} MB RSS")
+
+
 if __name__ == "__main__":
-    print("Running lightweight benchmark (matching original)...")
+    print("Running lightweight benchmark...")
     run_lightweight_benchmark()
 
     print("\n" + "=" * 80 + "\n")
 
-    print("Running full benchmark (with interpolation)...")
+    print("Running full workflow benchmark...")
     run_full_benchmark()
+
+    print("\n" + "=" * 80 + "\n")
+
+    print("Running stress test...")
+    run_performance_stress_test()
diff --git a/packages/python/goatlib/tests/integration/network/test_interpolation.py b/packages/python/goatlib/tests/integration/network/test_interpolation.py
new file mode 100644
index 000000000..38611d16f
--- /dev/null
+++ b/packages/python/goatlib/tests/integration/network/test_interpolation.py
@@ -0,0 +1,273 @@
+import logging
+from pathlib import Path
+
+from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
+from goatlib.routing.schemas.base import Coordinates
+
+logger = logging.getLogger(__name__)
+
+
+def test_interpolate_point_on_edge(network_file: Path) -> None:
+    """Test interpolating a point along an edge with comprehensive validation."""
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        # Try to split
+        split_table, split_meta = proc.split_edge_at_point_with_subset(
+            point=Coordinates(lat=48.137154, lon=11.576124),
+            network_buffer_radius=500.0,
+            max_search_radius_m=100.0,
+        )
+
+        split_stats = proc.get_network_stats(split_table)
+        logger.info(f"Split network: {split_stats['edge_count']} edges")
+
+        # Interpolate long edges (> 50m)
+        new_table, new_meta = proc.interpolate_long_edges(
+            base_table=split_table,
+            max_edge_length=10.0,
+            include_stats=True,
+        )
+
+        new_stats = proc.get_network_stats(new_table)
+        logger.info(f"Interpolated network: {new_stats['edge_count']} edges")
+
+        # Basic assertion
+        assert (
+            new_stats["edge_count"] >= split_stats["edge_count"]
+        ), f"Interpolation should increase edge count, but {new_stats['edge_count']} < {split_stats['edge_count']}"
+
+        # 1. CHECK: Metadata exists
+        assert (
+            split_meta.raw_meta.get("split_operation", {}) is not None
+        ), "Missing split metadata"
+        assert (
+            new_meta.raw_meta.get("interpolation_operation", {}) is not None
+        ), "Missing interpolation metadata"
+
+        # 2. CHECK: No edges longer than max threshold (with small tolerance)
+        max_allowed = 50.0 * 1.1  # 10% tolerance
+        max_edge_result = proc.con.execute(f"""
+            SELECT MAX(length_m) as max_length
+            FROM {new_table}
+        """).fetchone()
+
+        max_length = max_edge_result[0] if max_edge_result[0] else 0
+        assert (
+            max_length <= max_allowed
+        ), f"Found segment {max_length:.1f}m > max allowed {max_allowed:.1f}m"
+        logger.info(f"✓ Max segment length: {max_length:.1f}m (threshold: 50.0m)")
+
+        # 3. CHECK: Total length preserved (within 1%)
+        total_length_original = (
+            proc.con.execute(f"""
+            SELECT SUM(length_m) FROM {split_table}
+        """).fetchone()[0]
+            or 0
+        )
+
+        total_length_new = (
+            proc.con.execute(f"""
+            SELECT SUM(length_m) FROM {new_table}
+        """).fetchone()[0]
+            or 0
+        )
+
+        if total_length_original > 0:
+            length_diff = abs(total_length_new - total_length_original)
+            length_diff_pct = length_diff / total_length_original * 100
+
+            assert (
+                length_diff_pct < 1.0
+            ), f"Total length changed by {length_diff_pct:.2f}% (> 1% tolerance)"
+            logger.info(
+                f"✓ Total length preserved: {total_length_original:.1f}m → {total_length_new:.1f}m ({length_diff_pct:.2f}% diff)"
+            )
+
+        # 4. CHECK: All interpolated edges have proper naming
+        bad_names = proc.con.execute(f"""
+            SELECT COUNT(*)
+            FROM {new_table} 
+            WHERE edge_id LIKE '%_seg_%'
+              AND NOT REGEXP_MATCHES(edge_id, '_seg_[0-9]+$')
+        """).fetchone()[0]
+
+        assert bad_names == 0, f"Found {bad_names} edges with malformed segment names"
+        logger.info("✓ All segment names are properly formatted")
+
+        # 5. CHECK: Node connectivity - each interpolated node connects exactly 2 edges
+        node_connectivity = proc.con.execute(f"""
+            WITH interpolated_nodes AS (
+                SELECT DISTINCT source as node_id FROM {new_table} WHERE source LIKE 'interp_%'
+                UNION
+                SELECT DISTINCT target as node_id FROM {new_table} WHERE target LIKE 'interp_%'
+            ),
+            connections AS (
+                SELECT 
+                    n.node_id,
+                    COUNT(e.edge_id) as connection_count
+                FROM interpolated_nodes n
+                LEFT JOIN {new_table} e ON n.node_id = e.source OR n.node_id = e.target
+                GROUP BY n.node_id
+            )
+            SELECT 
+                COUNT(*) as total_interpolated_nodes,
+                COUNT(*) FILTER (WHERE connection_count != 2) as bad_nodes
+            FROM connections
+        """).fetchone()
+
+        assert (
+            node_connectivity[1] == 0
+        ), f"Found {node_connectivity[1]} interpolated nodes with != 2 connections"
+        logger.info(
+            f"✓ All {node_connectivity[0]} interpolated nodes have exactly 2 connections"
+        )
+
+        # 6. CHECK: Geometry validity
+        invalid_geoms = proc.con.execute(f"""
+            SELECT COUNT(*) 
+            FROM {new_table} 
+            WHERE ST_GeometryType({proc._meta.geometry_column}) != 'LINESTRING'
+               OR ST_IsEmpty({proc._meta.geometry_column})
+        """).fetchone()[0]
+
+        assert invalid_geoms == 0, f"Found {invalid_geoms} invalid geometries"
+        logger.info("✓ All geometries are valid LINESTRINGs")
+
+        # 7. CHECK: Segment ordering for each original edge
+        segment_ordering = proc.con.execute(f"""
+            WITH segments AS (
+                SELECT 
+                    edge_id,
+                    SPLIT_PART(edge_id, '_seg_', 1) as original_edge,
+                    TRY_CAST(SPLIT_PART(edge_id, '_seg_', 2) AS INTEGER) as segment_num
+                FROM {new_table}
+                WHERE edge_id LIKE '%_seg_%'
+                AND TRY_CAST(SPLIT_PART(edge_id, '_seg_', 2) AS INTEGER) IS NOT NULL
+            ),
+            ordering_issues AS (
+                SELECT 
+                    original_edge,
+                    COUNT(*) as total_segments,
+                    COUNT(DISTINCT segment_num) as unique_segments,
+                    MIN(segment_num) as min_segment,
+                    MAX(segment_num) as max_segment,
+                    LIST_SORT(LIST(segment_num)) as segment_list
+                FROM segments
+                GROUP BY original_edge
+                HAVING COUNT(DISTINCT segment_num) != COUNT(*)
+                   OR MIN(segment_num) != 1
+                   OR MAX(segment_num) != COUNT(*)
+            )
+            SELECT COUNT(*) as ordering_problems FROM ordering_issues
+        """).fetchone()[0]
+
+        assert (
+            segment_ordering == 0
+        ), f"Found {segment_ordering} edges with segment ordering issues"
+        logger.info("✓ All segments are properly numbered (1, 2, 3...)")
+
+        # 8. CHECK: No duplicate edge IDs
+        duplicate_edges = proc.con.execute(f"""
+            SELECT COUNT(*) - COUNT(DISTINCT edge_id) 
+            FROM {new_table}
+        """).fetchone()[0]
+
+        assert duplicate_edges == 0, f"Found {duplicate_edges} duplicate edge IDs"
+        logger.info("✓ No duplicate edge IDs")
+
+        # 9. CHECK: Cost proportional to length
+        cost_check = proc.con.execute(f"""
+            WITH interpolated_edges AS (
+                SELECT 
+                    edge_id,
+                    length_m,
+                    cost,
+                    cost / NULLIF(length_m, 0) as cost_per_meter
+                FROM {new_table}
+                WHERE edge_id LIKE '%_seg_%'
+                AND length_m > 0
+            ),
+            -- Group by original edge to check consistency within each split
+            edge_groups AS (
+                SELECT
+                    SPLIT_PART(edge_id, '_seg_', 1) as original_edge,
+                    AVG(cost_per_meter) as avg_cost_per_m,
+                    STDDEV_POP(cost_per_meter) as std_cost_per_m
+                FROM interpolated_edges
+                GROUP BY SPLIT_PART(edge_id, '_seg_', 1)
+            )
+            -- Check if any segment deviates significantly from its group average
+            SELECT COUNT(*)
+            FROM interpolated_edges ie
+            JOIN edge_groups eg ON SPLIT_PART(ie.edge_id, '_seg_', 1) = eg.original_edge
+            WHERE ABS(ie.cost_per_meter - eg.avg_cost_per_m) > 0.1 * eg.avg_cost_per_m  -- 10% tolerance
+        """).fetchone()[0]
+
+        assert (
+            cost_check == 0
+        ), f"Found {cost_check} segments with inconsistent cost/length ratios"
+        logger.info("✓ Cost distribution is consistent within each original edge")
+
+        # 10. CHECK: Network is connected
+        connectivity_check = proc.con.execute(f"""
+            WITH all_nodes AS (
+                SELECT source as node FROM {new_table}
+                UNION 
+                SELECT target as node FROM {new_table}
+            ),
+            node_degrees AS (
+                SELECT
+                    n.node,
+                    COUNT(e.edge_id) as degree
+                FROM all_nodes n
+                LEFT JOIN {new_table} e ON n.node = e.source OR n.node = e.target
+                GROUP BY n.node
+            )
+            SELECT COUNT(*) as isolated_nodes
+            FROM node_degrees
+            WHERE degree = 0
+        """).fetchone()[0]
+
+        assert connectivity_check == 0, f"Found {connectivity_check} isolated nodes"
+        logger.info("✓ No isolated nodes (all nodes have at least 1 connection)")
+
+        # 11. Segment endpoints should connect
+        disconnected_segments = proc.con.execute(f"""
+            WITH segments AS (
+                SELECT 
+                    edge_id,
+                    source,
+                    target,
+                    SPLIT_PART(edge_id, '_seg_', 1) as original_edge,
+                    TRY_CAST(SPLIT_PART(edge_id, '_seg_', 2) AS INTEGER) as seg_num,
+                    ST_StartPoint({proc._meta.geometry_column}) as start_geom,
+                    ST_EndPoint({proc._meta.geometry_column}) as end_geom
+                FROM {new_table}
+                WHERE edge_id LIKE '%_seg_%'
+            ),
+            connections AS (
+                SELECT
+                    s1.edge_id as edge1,
+                    s2.edge_id as edge2,
+                    ST_Distance(s1.end_geom, s2.start_geom) * 111320 as distance_m
+                FROM segments s1
+                JOIN segments s2 ON s1.original_edge = s2.original_edge 
+                    AND s1.seg_num + 1 = s2.seg_num
+                WHERE s1.seg_num IS NOT NULL AND s2.seg_num IS NOT NULL
+            )
+            SELECT COUNT(*) as disconnected_pairs
+            FROM connections
+            WHERE distance_m > 0.1  -- More than 10cm gap
+        """).fetchone()[0]
+
+        assert (
+            disconnected_segments == 0
+        ), f"Found {disconnected_segments} disconnected segment pairs"
+        logger.info("✓ All segment endpoints connect properly (< 10cm gaps)")
+
+        logger.info(
+            f"\n✅ SUCCESS: Interpolated network is valid!\n"
+            f"   Original: {split_stats['edge_count']} edges\n"
+            f"   After: {new_stats['edge_count']} edges\n"
+            f"   Max segment: {max_length:.1f}m\n"
+            f"   All checks passed ✓"
+        )
diff --git a/packages/python/goatlib/tests/integration/network/test_network_preprocessing.py b/packages/python/goatlib/tests/integration/network/test_network_preprocessing.py
index 628a250af..2e87d230c 100644
--- a/packages/python/goatlib/tests/integration/network/test_network_preprocessing.py
+++ b/packages/python/goatlib/tests/integration/network/test_network_preprocessing.py
@@ -3,6 +3,7 @@
 
 import pytest
 from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
+from goatlib.routing.schemas.base import Coordinates
 
 logger = logging.getLogger(__name__)
 
@@ -10,117 +11,118 @@
 def test_buffered_subset_creation(network_file: Path):
     """Test creating a spatial subset of network within a buffer."""
     # Munich city center coordinates
-    lat, lon = 48.1351, 11.5820
+    center = Coordinates(lat=48.1351, lon=11.5820)
     buffer_radius = 3000  # 3km
 
     with InMemoryNetworkProcessor(str(network_file)) as processor:
-        # Create buffered subset
-        subset_table = processor.create_buffered_subset(
-            latitude=lat, longitude=lon, buffer_radius=buffer_radius
+        # Create buffered subset using load_network (which creates subset)
+        subset_table = processor.load_network(
+            center=center, buffer_radius=buffer_radius
         )
 
-        # Verify subset table was created
-        available_tables = processor.get_available_tables()
-        assert subset_table in available_tables
-
         # Get statistics
-        subset_meta = processor.get_subset_metadata(
-            subset_table=subset_table,
-            latitude=lat,
-            longitude=lon,
-            buffer_radius=buffer_radius,
-        )
-
-        # Verify buffer operation metadata
-        assert "buffer_operation" in subset_meta.raw_meta
-        buffer_info = subset_meta.raw_meta["buffer_operation"]
-        assert buffer_info["operation"] == "spatial_buffer"
-        assert buffer_info["buffer_radius_m"] == buffer_radius
-        assert buffer_info["subset_edge_count"] > 0
-        assert buffer_info["subset_edge_count"] < buffer_info["original_edge_count"]
-        assert 0 < buffer_info["reduction_ratio"] < 1.0
-
-        # Verify subset is smaller than original
-        original_stats = processor.get_network_stats()
         subset_stats = processor.get_network_stats(subset_table)
-        assert subset_stats["edge_count"] < original_stats["edge_count"]
+        original_stats = processor.get_network_stats(processor.network_table_name)
+
+        # Verify subset is smaller than original (for reasonable buffer sizes)
+        if buffer_radius < 50000:  # Only check for modest buffers
+            assert subset_stats["edge_count"] < original_stats["edge_count"]
+
+        assert subset_stats["edge_count"] > 0
+        logger.info(
+            f"Created subset with {subset_stats['edge_count']} edges (original: {original_stats['edge_count']})"
+        )
 
 
 def test_edge_splitting_at_point(network_file: Path):
     """Test splitting closest edge at a given point."""
     # Point near Munich center
-    lat, lon = 48.1370, 11.5760
+    point = Coordinates(lat=48.1370, lon=11.5760)
 
     with InMemoryNetworkProcessor(str(network_file)) as processor:
-        # First create a buffered subset for faster testing
-        subset_table = processor.create_buffered_subset(
-            latitude=lat, longitude=lon, buffer_radius=2000
-        )
+        # First load a buffered subset for faster testing
+        subset_table = processor.load_network(center=point, buffer_radius=2000)
 
         # Split edge at the point
         split_table, split_meta = processor.split_edge_at_point(
-            latitude=lat,
-            longitude=lon,
-            base_table=subset_table,
-            max_search_radius=200,
+            point=point,
+            source_table=subset_table,
+            max_search_radius_m=200,
         )
 
-        # Verify split table was created
-        available_tables = processor.get_available_tables()
-        assert split_table in available_tables
-
         # Verify split operation metadata
         assert "split_operation" in split_meta.raw_meta
         split_info = split_meta.raw_meta["split_operation"]
-        assert split_info["operation"] == "edge_split"
-        assert split_info["method"] == "bbox_optimization"
         assert "artificial_node_id" in split_info
-        assert "original_edge_split" in split_info
-        assert 0.0 <= split_info["split_fraction"] <= 1.0
-        assert split_info["distance_to_edge"] <= 200
+        assert "original_edge" in split_info
+        assert 0.0 <= split_info["split_position"]["fraction"] <= 1.0
 
         # Verify new node coordinates are close to input point
-        new_node = split_info["new_node_coords"]
-        assert abs(new_node["lat"] - lat) < 0.01  # Within ~1km
-        assert abs(new_node["lon"] - lon) < 0.01
+        actual_point = split_info["split_position"]["actual_point"]
+        assert abs(actual_point["lat"] - point.lat) < 0.01  # Within ~1km
+        assert abs(actual_point["lon"] - point.lon) < 0.01
 
         # Verify split table has more edges (original edge replaced with 2 parts)
         subset_stats = processor.get_network_stats(subset_table)
         split_stats = processor.get_network_stats(split_table)
         assert split_stats["edge_count"] == subset_stats["edge_count"] + 1
+        logger.info(
+            f"Split edge: {subset_stats['edge_count']} → {split_stats['edge_count']} edges"
+        )
+
+
+def test_split_edge_at_point_with_subset(network_file: Path):
+    """Test the combined split with subset method."""
+    point = Coordinates(lat=48.137154, lon=11.576124)
+
+    with InMemoryNetworkProcessor(str(network_file)) as proc:
+        # This loads subset and splits in one call
+        split_table, split_meta = proc.split_edge_at_point_with_subset(
+            point=point,
+            network_buffer_radius=500.0,
+            max_search_radius_m=100.0,
+        )
+
+        # Verify results
+        assert "split_operation" in split_meta.raw_meta
+
+        stats = proc.get_network_stats(split_table)
+        assert stats["edge_count"] > 0
+        logger.info(f"Split with subset: {stats['edge_count']} edges")
 
 
 def test_complete_preprocessing_workflow(network_file: Path):
     """Test the complete workflow: buffer → split → interpolate."""
     # Origin point
-    origin_lat, origin_lon = 48.1351, 11.5820
+    origin = Coordinates(lat=48.1351, lon=11.5820)
     buffer_radius = 5000  # 5km
 
     with InMemoryNetworkProcessor(str(network_file)) as processor:
         # Step 1: Create buffered subset
-        subset_table = processor.create_buffered_subset(
-            latitude=origin_lat, longitude=origin_lon, buffer_radius=buffer_radius
+        subset_table = processor.load_network(
+            center=origin, buffer_radius=buffer_radius
         )
 
         subset_stats = processor.get_network_stats(subset_table)
         assert subset_stats["edge_count"] > 0
-        print(f"\n📊 Subset contains {subset_stats['edge_count']} edges")
+        logger.info(f"📊 Subset contains {subset_stats['edge_count']} edges")
 
         # Step 2: Split edge at origin point
         split_table, split_meta = processor.split_edge_at_point(
-            latitude=origin_lat,
-            longitude=origin_lon,
-            base_table=subset_table,
-            max_search_radius=200,
+            point=origin,
+            source_table=subset_table,
+            max_search_radius_m=200,
         )
 
         origin_node_id = split_meta.raw_meta["split_operation"]["artificial_node_id"]
         assert origin_node_id is not None
-        assert origin_node_id.startswith("split_node_")
-        print(f"🎯 Origin node created: {origin_node_id}")
+        assert origin_node_id.startswith("split_node_") or origin_node_id.startswith(
+            "n_"
+        )
+        logger.info(f"🎯 Origin node created: {origin_node_id}")
 
         split_stats = processor.get_network_stats(split_table)
-        print(f"📈 Split network has {split_stats['edge_count']} edges")
+        logger.info(f"📈 Split network has {split_stats['edge_count']} edges")
 
         # Verify edges are connected to the artificial node
         connected_edges = processor.con.execute(
@@ -130,8 +132,21 @@ def test_complete_preprocessing_workflow(network_file: Path):
             WHERE source = '{origin_node_id}' OR target = '{origin_node_id}'
             """
         ).fetchone()[0]
-        assert connected_edges > 0
-        print(f"🔗 {connected_edges} edges connected to origin node")
+        assert connected_edges == 2  # Should connect exactly 2 edges (the split parts)
+        logger.info(f"🔗 {connected_edges} edges connected to origin node")
+
+        # Step 3: Interpolate long edges
+        interpolated_table, interp_meta = processor.interpolate_long_edges(
+            max_edge_length=50.0,
+            base_table=split_table,
+            include_stats=True,
+        )
+
+        interp_stats = processor.get_network_stats(interpolated_table)
+        logger.info(f"✂️  Interpolated to {interp_stats['edge_count']} edges")
+
+        # Verify workflow produced valid network
+        assert interp_stats["edge_count"] > split_stats["edge_count"]
 
 
 def test_edge_interpolation(network_file: Path):
@@ -139,49 +154,89 @@ def test_edge_interpolation(network_file: Path):
     max_edge_length = 100.0  # Split edges longer than 100m
 
     with InMemoryNetworkProcessor(str(network_file)) as processor:
+        # Load a subset first for faster testing
+        center = Coordinates(lat=48.1351, lon=11.5820)
+        subset_table = processor.load_network(center=center, buffer_radius=2000)
+
         # Get original stats
-        original_stats = processor.get_network_stats()
-        print(f"\n📊 Original network: {original_stats['edge_count']} edges")
-        print(f"   Max edge length: {original_stats['max_length_m']:.2f}m")
+        original_stats = processor.get_network_stats(subset_table)
+        logger.info(f"\n📊 Original network: {original_stats['edge_count']} edges")
+        logger.info(f"   Max edge length: {original_stats['max_length_m']:.2f}m")
 
         # Count long edges
         long_edges = processor.con.execute(
             f"""
             SELECT COUNT(*)
-            FROM {processor.network_table_name}
+            FROM {subset_table}
             WHERE length_m > {max_edge_length}
             """
         ).fetchone()[0]
-        print(f"   Long edges (>{max_edge_length}m): {long_edges}")
+        logger.info(f"   Long edges (>{max_edge_length}m): {long_edges}")
 
         # Interpolate long edges
         interpolated_table, interp_meta = processor.interpolate_long_edges(
-            max_edge_length=max_edge_length
+            max_edge_length=max_edge_length,
+            base_table=subset_table,
+            include_stats=True,
         )
 
         # Verify interpolation metadata
-        assert "interpolation_operation" in interp_meta.raw_meta
-        interp_info = interp_meta.raw_meta["interpolation_operation"]
-        assert interp_info["max_edge_length_threshold"] == max_edge_length
-        assert interp_info["long_edges_processed"] == long_edges
-        assert interp_info["final_edge_count"] > interp_info["original_edge_count"]
-        assert interp_info["edges_added"] > 0
-        assert interp_info["new_intermediate_nodes"] > 0
-
-        print(f"✂️  Interpolated network: {interp_info['final_edge_count']} edges")
-        print(f"   Edges added: {interp_info['edges_added']}")
-        print(f"   New intermediate nodes: {interp_info['new_intermediate_nodes']}")
-        print(f"   Processing time: {interp_info['processing_time_seconds']:.3f}s")
-
-        # Verify no edge exceeds max length
-        longest_edge = processor.con.execute(
-            f"""
+        if "stats" in interp_meta.raw_meta:
+            stats = interp_meta.raw_meta["stats"]
+            logger.info(f"✂️  Segments created: {stats.get('segments_added', 'N/A')}")
+            logger.info(
+                f"   Max segment: {stats.get('max_segment_length', 'N/A'):.1f}m"
+            )
+        elif "interpolation_operation" in interp_meta.raw_meta:
+            interp_info = interp_meta.raw_meta["interpolation_operation"]
+            logger.info(
+                f"✂️  Interpolated network: {interp_info.get('final_edge_count', 'N/A')} edges"
+            )
+            logger.info(f"   Edges added: {interp_info.get('edges_added', 'N/A')}")
+
+        # Verify no edge exceeds max length (with tolerance)
+        longest_edge = (
+            processor.con.execute(
+                f"""
             SELECT MAX(length_m)
             FROM {interpolated_table}
+            WHERE edge_id LIKE '%_s%' OR edge_id LIKE '%_seg_%'
             """
-        ).fetchone()[0]
-        assert longest_edge <= max_edge_length * 1.01  # Allow 1% tolerance
-        print(f"   New max edge length: {longest_edge:.2f}m ✅")
+            ).fetchone()[0]
+            or 0
+        )
+        assert longest_edge <= max_edge_length * 1.1  # Allow 10% tolerance
+        logger.info(f"   New max segment length: {longest_edge:.2f}m ✅")
+
+
+def test_interpolate_point_on_edge(network_file: Path):
+    """Test interpolating a point along an edge."""
+    with InMemoryNetworkProcessor(str(network_file)) as proc:
+        # First split at a point
+        split_table, split_meta = proc.split_edge_at_point_with_subset(
+            point=Coordinates(lat=48.137154, lon=11.576124),
+            network_buffer_radius=500.0,
+            max_search_radius_m=100.0,
+        )
+
+        split_stats = proc.get_network_stats(split_table)
+        logger.info(f"Split network: {split_stats['edge_count']} edges")
+
+        # Then interpolate long edges
+        new_table, new_meta = proc.interpolate_long_edges(
+            base_table=split_table,
+            max_edge_length=50.0,
+        )
+
+        new_stats = proc.get_network_stats(new_table)
+        logger.info(f"Interpolated network: {new_stats['edge_count']} edges")
+
+        # Basic checks
+        assert new_stats["edge_count"] >= split_stats["edge_count"]
+        assert split_meta.raw_meta.get("split_operation", {}) is not None
+
+        # Check metadata exists (structure depends on include_stats)
+        assert new_meta.raw_meta is not None
 
 
 @pytest.mark.parametrize(
@@ -196,26 +251,118 @@ def test_buffer_radius_variations(
     network_file: Path, lat: float, lon: float, buffer_radius: float
 ):
     """Test that larger buffers result in more edges."""
+    center = Coordinates(lat=lat, lon=lon)
+
     with InMemoryNetworkProcessor(str(network_file)) as processor:
-        subset_table = processor.create_buffered_subset(
-            latitude=lat, longitude=lon, buffer_radius=buffer_radius
+        subset_table = processor.load_network(
+            center=center, buffer_radius=buffer_radius
         )
 
         stats = processor.get_network_stats(subset_table)
-        print(f"\n📏 Buffer {buffer_radius}m: {stats['edge_count']} edges")
+        logger.info(f"\n📏 Buffer {buffer_radius}m: {stats['edge_count']} edges")
 
-        # Verify proportional relationship exists
+        # Verify proportional relationship exists (larger buffer = more edges)
         assert stats["edge_count"] > 0
 
 
 def test_error_handling_point_too_far_from_network(network_file: Path):
     """Test error handling when point is too far from any edge."""
-    # Point in the middle of nowhere
-    lat, lon = 0.0, 0.0
-
-    with InMemoryNetworkProcessor(str(network_file)) as processor:
-        # Try to split - should raise error
-        with pytest.raises(ValueError, match="No edges found within"):
-            processor.split_edge_at_point(
-                latitude=lat, longitude=lon, max_search_radius=100
+    # Point in the middle of nowhere (Atlantic Ocean)
+    point = Coordinates(lat=0.0, lon=0.0)
+
+    with InMemoryNetworkProcessor(str(network_file)) as proc:
+        # load_network should work (creates empty or small subset)
+        subset_table = proc.load_network(center=point, buffer_radius=1000)
+
+        # But split_edge_at_point should fail
+        with pytest.raises(ValueError, match="No edge found within"):
+            proc.split_edge_at_point(
+                point=point,
+                source_table=subset_table,
+                max_search_radius_m=1000.0,  # Even large radius
             )
+
+
+def test_error_handling_invalid_split_position(network_file: Path):
+    """Test error handling when split point is at edge endpoint."""
+    with InMemoryNetworkProcessor(str(network_file)) as proc:
+        # Load a subset
+        center = Coordinates(lat=48.1351, lon=11.5820)
+        subset_table = proc.load_network(center=center, buffer_radius=1000)
+
+        # Find an actual edge endpoint to test
+        result = proc.con.execute(f"""
+            SELECT 
+                source,
+                ST_X(ST_StartPoint({proc._meta.geometry_column})) as start_lon,
+                ST_Y(ST_StartPoint({proc._meta.geometry_column})) as start_lat
+            FROM {subset_table}
+            LIMIT 1
+        """).fetchone()
+
+        if result:
+            # Try to split at the exact start of an edge
+            point = Coordinates(lat=result[2], lon=result[1])
+
+            # This might fail or warn depending on implementation
+            try:
+                split_table, meta = proc.split_edge_at_point(
+                    point=point,
+                    source_table=subset_table,
+                    max_search_radius_m=10.0,
+                )
+                # If it succeeds, check warning in metadata
+                logger.info("Split at endpoint succeeded (fraction should be ~0)")
+            except ValueError as e:
+                if "too close to endpoint" in str(e):
+                    logger.info(f"Correctly rejected split at endpoint: {e}")
+                else:
+                    raise
+
+
+def test_network_stats_method(network_file: Path):
+    """Test the get_network_stats method."""
+    with InMemoryNetworkProcessor(str(network_file)) as proc:
+        # Test on main network
+        proc.load_network()
+        stats = proc.get_network_stats()
+        assert "edge_count" in stats
+        assert "total_length_m" in stats
+        assert "avg_length_m" in stats
+        assert stats["edge_count"] > 0
+
+        logger.info(
+            f"Main network: {stats['edge_count']} edges, {stats['total_length_m']:.0f}m total"
+        )
+
+        # Test on subset
+        subset = proc.load_network(
+            center=Coordinates(lat=48.1351, lon=11.5820), buffer_radius=1000
+        )
+        subset_stats = proc.get_network_stats(subset)
+        assert subset_stats["edge_count"] > 0
+        assert subset_stats["edge_count"] <= stats["edge_count"]
+
+
+def test_apply_sql_query(network_file: Path):
+    """Test applying custom SQL queries."""
+    with InMemoryNetworkProcessor(str(network_file)) as proc:
+        table = proc.load_network(
+            center=Coordinates(lat=48.1351, lon=11.5820), buffer_radius=2000
+        )
+        # Create a simple filtered table
+        result_table = proc.apply_sql_query(
+            sql_query=f"""
+            SELECT * 
+            FROM {table} 
+            WHERE length_m > 100 
+            LIMIT 10
+            """,
+            result_table="long_edges",
+        )
+
+        stats = proc.get_network_stats(result_table)
+        assert stats["edge_count"] <= 10
+        assert stats["min_length_m"] > 100
+
+        logger.info(f"SQL query created table with {stats['edge_count']} edges > 100m")
diff --git a/packages/python/goatlib/tests/unit/analysis/test_network.py b/packages/python/goatlib/tests/unit/analysis/test_network.py
index f51ccda92..d49081c05 100644
--- a/packages/python/goatlib/tests/unit/analysis/test_network.py
+++ b/packages/python/goatlib/tests/unit/analysis/test_network.py
@@ -63,26 +63,6 @@ def test_network_loading_with_point(
     processor.save_network(table_name, output_path)
 
 
-def test_split_with_subset(network_file: Path) -> None:
-    """Test splitting edge on a network subset without loading full network."""
-    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
-        # This loads only ~500m radius around the point, not the full 375k edges
-        split_table, split_meta = proc.split_edge_at_point_with_subset(
-            point=Coordinates(lat=48.137154, lon=11.576124),
-            network_buffer_radius=500.0,
-            max_search_radius=100.0,
-        )
-        tables = proc.get_available_tables()
-        logger.info(f"Available tables after split: {tables}")
-
-        stats = proc.get_network_stats(split_table)
-        assert stats["edge_count"] < 375164
-
-        # Verify the split worked
-        assert split_meta.raw_meta["split_operation"]["artificial_node_id"] is not None
-        logger.info(f"Split edge on subset: {split_meta.raw_meta['split_operation']}")
-
-
 def test_save_to_file(processor: InMemoryNetworkProcessor, data_root: Path) -> None:
     """Test saving a table to a parquet file."""
     output_file = data_root / "network" / "network_output.parquet"
@@ -127,81 +107,150 @@ def test_get_available_tables(
     logger.info(f"Available tables: {tables}")
 
 
-# `------------ Complex Operation Tests ------------
+def test_split_with_subset_basic(network_file: Path) -> None:
+    """Basic test that splitting works."""
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        # Try to split
+        split_table, split_meta = proc.split_edge_at_point_with_subset(
+            point=Coordinates(lat=48.137154, lon=11.576124),
+            network_buffer_radius=500.0,
+            max_search_radius_m=100.0,
+        )
 
+        # Basic assertions
+        assert split_table in proc.get_available_tables()
 
-def test_interpolate_long_edges(processor: InMemoryNetworkProcessor) -> None:
-    """Test edge interpolation functionality."""
-    # Get original network stats
-    original_stats = processor.get_network_stats()
+        stats = proc.get_network_stats(split_table)
+        assert 0 < stats["edge_count"] < 375164
 
-    # Find a reasonable threshold - use 75th percentile of edge lengths
-    edge_lengths = processor.con.execute(f"""
-        SELECT length_m FROM {processor.network_table_name}
-        ORDER BY length_m DESC
-    """).fetchall()
+        split_info = split_meta.raw_meta.get("split_operation", {})
+        assert split_info.get("original_edge")
+        assert split_info.get("artificial_node_id")
 
-    if len(edge_lengths) < 4:
-        # Skip test if network is too small
-        return
+        # Quick validation of split
+        fraction = split_info["split_position"]["fraction"]
+        assert 0.0 <= fraction <= 1.0
 
-    # Use a threshold that will catch some but not all edges
-    max_length = edge_lengths[len(edge_lengths) // 4][0]  # 75th percentile
-    interpolation_distance = max_length / 3  # Create multiple segments
+        logger.info(f"Basic test passed: split {split_info['original_edge']}")
 
-    # Perform interpolation
-    interpolated_table, interpolated_meta = processor.interpolate_long_edges(
-        max_edge_length=max_length, interpolation_distance=interpolation_distance
-    )
 
-    # Extract interpolation info from metadata
-    info = interpolated_meta.raw_meta["interpolation_operation"]
-
-    # Verify interpolation info
-    assert info["original_edge_count"] == original_stats["edge_count"]
-    assert info["max_edge_length_threshold"] == max_length
-    assert info["interpolation_distance"] == interpolation_distance
-    assert (
-        info["final_edge_count"] >= info["original_edge_count"]
-    )  # Should have more edges
-    assert info["processing_time_seconds"] > 0
-
-    # Verify the interpolated network has valid stats
-    interpolated_stats = processor.get_network_stats(interpolated_table)
-    assert interpolated_stats["edge_count"] == info["final_edge_count"]
-    assert interpolated_stats["edge_count"] > 0
-
-    # Check that no edge in the interpolated network exceeds the threshold
-    long_edges_count = processor.con.execute(f"""
-        SELECT COUNT(*) FROM {interpolated_table} WHERE length_m > {max_length}
-    """).fetchone()[0]
-    assert (
-        long_edges_count == 0
-    ), f"Found {long_edges_count} edges still longer than {max_length}m"
-
-    # Verify intermediate nodes were created
-    if info["new_intermediate_nodes"] > 0:
-        intermediate_nodes = processor.con.execute(f"""
-            SELECT COUNT(DISTINCT node_id) FROM (
-                SELECT source as node_id FROM {interpolated_table} WHERE source LIKE 'interp_%'
-                UNION 
-                SELECT target as node_id FROM {interpolated_table} WHERE target LIKE 'interp_%'
-            )
-        """).fetchone()[0]
-        assert intermediate_nodes > 0, "Should have created intermediate nodes"
-
-    # Verify total length is preserved (approximately)
-    original_total_length = original_stats["total_length_m"]
-    interpolated_total_length = interpolated_stats["total_length_m"]
-    length_diff = abs(original_total_length - interpolated_total_length)
-    assert (
-        length_diff / original_total_length < 0.01
-    ), f"Total length changed too much: {length_diff}m"
-
-    logger.info("Interpolation test completed:")
-    logger.info(f"  Original edges: {info['original_edge_count']}")
-    logger.info(f"  Long edges processed: {info['long_edges_processed']}")
-    logger.info(f"  Final edges: {info['final_edge_count']}")
-    logger.info(f"  New intermediate nodes: {info['new_intermediate_nodes']}")
-    logger.info(f"  Max edge length threshold: {max_length:.1f}m")
-    logger.info(f"  Processing time: {info['processing_time_seconds']:.2f}s")
+def test_split_with_subset_advanced(network_file: Path) -> None:
+    """Test splitting edge on a network subset without loading full network."""
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        # This loads only ~500m radius around the point, not the full 375k edges
+        split_table, split_meta = proc.split_edge_at_point_with_subset(
+            point=Coordinates(lat=48.137154, lon=11.576124),
+            network_buffer_radius=500.0,
+            max_search_radius_m=100.0,
+        )
+
+        # Get available tables
+        tables = proc.get_available_tables()
+        logger.info(f"Available tables after split: {tables}")
+
+        # Check that split table exists
+        assert split_table in tables, f"Split table {split_table} not found in {tables}"
+
+        # Get stats for split table
+        stats = proc.get_network_stats(split_table)
+        logger.info(f"Split table stats: {stats}")
+
+        # Verify the subset is smaller than full network
+        assert (
+            stats["edge_count"] < 375164
+        ), "Subset should be smaller than full network"
+        assert stats["edge_count"] > 0, "Subset should have at least one edge"
+
+        # Verify the split worked
+        split_info = split_meta.raw_meta.get("split_operation", {})  # Fixed key name
+        assert split_info.get("original_edge") is not None, "Missing original edge ID"
+        assert split_info.get("artificial_node_id") is not None, "Missing new node ID"
+        assert (
+            split_info.get("split_position", {}).get("fraction") is not None
+        ), "Missing split fraction"
+
+        # Verify split fraction is reasonable
+        fraction = split_info["split_position"]["fraction"]
+        assert (
+            0.001 <= fraction <= 0.999
+        ), f"Split fraction {fraction} should be between 0.001 and 0.999"
+
+        # Verify distance is within search radius
+        distance_m = split_info["split_position"]["distance_m"]
+        assert (
+            distance_m <= 100.0
+        ), f"Distance {distance_m}m should be <= search radius 100m"
+
+        # Additional useful checks:
+
+        # 1. Check that split edge appears twice (parts A and B)
+        result = proc.con.execute(f"""
+            SELECT COUNT(*) 
+            FROM {split_table} 
+            WHERE edge_id LIKE '%_A' OR edge_id LIKE '%_B'
+        """).fetchone()
+        split_edge_count = result[0]
+        assert (
+            split_edge_count == 2
+        ), f"Should have 2 split edges, got {split_edge_count}"
+
+        # 2. Check new node connectivity
+        node_id = split_info["artificial_node_id"]
+        result = proc.con.execute(f"""
+            SELECT 
+                COUNT(*) as connections,
+                SUM(CASE WHEN source = '{node_id}' THEN 1 ELSE 0 END) as as_source,
+                SUM(CASE WHEN target = '{node_id}' THEN 1 ELSE 0 END) as as_target
+            FROM {split_table}
+            WHERE source = '{node_id}' OR target = '{node_id}'
+        """).fetchone()
+
+        assert result[0] == 2, f"New node should connect 2 edges, connects {result[0]}"
+        assert (
+            result[1] == 1
+        ), f"New node should be source for 1 edge, is source for {result[1]}"
+        assert (
+            result[2] == 1
+        ), f"New node should be target for 1 edge, is target for {result[2]}"
+
+        # 3. Check edge lengths sum correctly
+        original_length = split_info["edge_properties"]["original_length_m"]
+        part_a_length = split_info["edge_properties"]["part_a_length_m"]
+        part_b_length = split_info["edge_properties"]["part_b_length_m"]
+
+        # Allow small floating point tolerance
+        total_split_length = part_a_length + part_b_length
+        length_diff = abs(original_length - total_split_length)
+        assert (
+            length_diff < 0.01
+        ), f"Split lengths don't sum to original: {original_length} != {total_split_length}"
+
+        logger.info(
+            f"✅ Test passed: Split {split_info['original_edge']} at {fraction:.3%}"
+        )
+        logger.info(f"   New node: {node_id}, Distance: {distance_m:.1f}m")
+        logger.info(f"   Part A: {part_a_length:.1f}m, Part B: {part_b_length:.1f}m")
+
+
+def test_interpolate_point_on_edge(network_file: Path) -> None:
+    """Test interpolating a point along an edge."""
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        # Try to split
+        split_table, split_meta = proc.split_edge_at_point_with_subset(
+            point=Coordinates(lat=48.137154, lon=11.576124),
+            network_buffer_radius=500.0,
+            max_search_radius_m=100.0,
+        )
+        stats = proc.get_network_stats(split_table)
+        new_table, new_meta = proc.interpolate_long_edges(
+            base_table=split_table,
+            max_edge_length=50.0,
+        )
+        new_stats = proc.get_network_stats(new_table)
+
+        assert new_stats["edge_count"] >= stats["edge_count"]
+        logger.info(
+            f"Interpolated long edges: {stats['edge_count']} → {new_stats['edge_count']} edges"
+        )
+        assert split_meta.raw_meta.get("split_operation", {}) is not None
+        assert new_meta.raw_meta.get("interpolation_operation", {}) is not None

From 7e0ecf3c0da610e1243941302fba611b1ddd6600 Mon Sep 17 00:00:00 2001
From: 96hoshi <marta.locascio@plan4better.de>
Date: Tue, 16 Dec 2025 14:38:20 +0000
Subject: [PATCH 07/11] refactor: added integration test with rust fast_routing

---
 .../analysis/network/network_processor.py     | 782 ++++++++----------
 .../benchmark_network_memory_usage.py         | 335 --------
 .../benchmarks/test_network_performance.py    | 400 +++++++++
 .../integration/network/test_interpolation.py | 273 ------
 .../network/test_network_preprocessing.py     | 368 ---------
 .../routing/network/test_catchment.py         | 225 +++++
 .../tests/unit/analysis/test_network.py       | 392 ++++-----
 7 files changed, 1179 insertions(+), 1596 deletions(-)
 delete mode 100644 packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
 create mode 100644 packages/python/goatlib/tests/benchmarks/test_network_performance.py
 delete mode 100644 packages/python/goatlib/tests/integration/network/test_interpolation.py
 delete mode 100644 packages/python/goatlib/tests/integration/network/test_network_preprocessing.py
 create mode 100644 packages/python/goatlib/tests/integration/routing/network/test_catchment.py

diff --git a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
index 78bed25ea..4b6a801b8 100644
--- a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
+++ b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
@@ -1,113 +1,48 @@
 import logging
 import math
+import tempfile
 import time
 import uuid
-from typing import Any, Dict, Set
+from pathlib import Path
+from typing import Optional, Tuple
 
-from goatlib.analysis.core.base import AnalysisTool
-from goatlib.io.utils import Metadata
+import duckdb
+from goatlib.io.utils import ColumnMeta, Metadata
 from goatlib.routing.schemas.base import Coordinates
 
-SPLIT_EPSILON = 1e-6  # Configurable threshold
-
 logger = logging.getLogger(__name__)
 
-# from .super I have only: cleanup, init and import_input
+SPLIT_EPSILON = 1e-6
 
 
-class InMemoryNetworkProcessor(AnalysisTool):
+class InMemoryNetworkProcessor:
     """
-    In-memory network processor for routing.
+    Optimized in-memory network processor that reads only necessary data.
     """
 
     def __init__(self, input_path: str) -> None:
-        super().__init__(db_path=input_path)
-        self._is_loaded = False
-        self._network_table_name: str
-        self._meta: Metadata
-        self._created_tables: Set[str] = set()  # Track tables we create
-        self._original_tables: Set[str] = set()  # Tables that existed at init
+        self._db_path = Path(input_path)
+        self._temp_dir = tempfile.mkdtemp(prefix="routing_")
 
-    def __enter__(self) -> "InMemoryNetworkProcessor":
-        return self
+        # Connect to DuckDB with optimal settings
+        self.con = duckdb.connect(database=":memory:")
+        self._setup_duckdb_extensions()
 
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
-        super().cleanup()
+        # Lazy metadata loading
+        self._meta = None
+        self._network_table_name = "network_data"
+        self._is_loaded = False
 
-    @property
-    def network_table_name(self) -> str:
-        self._ensure_loaded()
-        return self._network_table_name
+    # ==================== PUBLIC API METHODS ====================
+    # These are the main methods users will call
 
     @property
-    def network_metadata(self) -> Metadata:
-        self._ensure_loaded()
+    def metadata(self) -> Metadata:
+        """Get metadata with lazy loading"""
+        if self._meta is None:
+            self._meta = self._load_metadata_only()
         return self._meta
 
-    def _ensure_loaded(self) -> None:
-        """Ensure the network is loaded before performing operations."""
-        if not self._is_loaded:
-            raise RuntimeError("Network not loaded. Call load_network() first.")
-
-    def _get_all_tables_safe(self) -> list[str]:
-        """Safely get all table names."""
-        try:
-            result = self.con.execute("""
-                SELECT table_name 
-                FROM information_schema.tables 
-                WHERE table_schema = 'main'
-                ORDER BY table_name
-            """).fetchall()
-            return [row[0] for row in result] if result else []
-        except:
-            return []
-
-    def get_network_stats(self, table_name: str = None) -> Dict[str, Any]:
-        """Get basic statistics about the network.
-
-        Args:
-            table_name: Optional table name to get stats for. If None, uses the main network table.
-        """
-        self._ensure_loaded()
-        target_table = table_name if table_name else self._network_table_name
-        result = self.con.execute(f"""
-            SELECT
-                COUNT(*) as edge_count,
-                SUM(length_m) as total_length_m,
-                AVG(length_m) as avg_length_m,
-                MIN(length_m) as min_length_m,
-                MAX(length_m) as max_length_m
-            FROM {target_table}
-        """).fetchone()
-
-        return {
-            "edge_count": result[0],
-            "total_length_m": float(result[1]) if result[1] else 0,
-            "avg_length_m": float(result[2]) if result[2] else 0,
-            "min_length_m": float(result[3]) if result[3] else 0,
-            "max_length_m": float(result[4]) if result[4] else 0,
-        }
-
-    # def _get_available_tables(self) -> list[str]:
-    #     """Returns a list of available table names in the DuckDB database. used for testing purposes."""
-    #     result = self.con.execute("SHOW TABLES").fetchall()
-    #     return [row[0] for row in result]
-
-    def apply_sql_query(
-        self, sql_query: str, result_table: str = "query_result"
-    ) -> str:
-        """Applies SQL and returns a NEW table, without destroying the input."""
-        self._ensure_loaded()
-        result_table = f"{result_table}_{uuid.uuid4().hex[:8]}"
-        try:
-            # WARNING: This does not sanitize input SQL - use with caution in production
-            self.con.execute(f"CREATE TABLE {result_table} AS {sql_query}")
-            logger.info(f"Created result table: {result_table}")
-            return result_table
-        except Exception as e:
-            logger.error(f"Failed to execute SQL query: {e}")
-            raise
-
     def load_network(
         self,
         center: Coordinates = None,
@@ -116,294 +51,266 @@ def load_network(
         speed_kmh: float = 5.0,
     ) -> str:
         """
-        Cut network for routing operations with configurable parameters.
-
-        Returns:
-            Tuple of (table_name, buffer_distance_meters)
+        Load only the necessary network subset using predicate pushdown.
+        Returns table name where data is stored.
         """
-        self._meta, self._network_table_name = super().import_input(self._db_path)
-        logger.info(f"Network loaded into table: {self._network_table_name}")
-
-        # Validate required columns exist
-        if not self._meta.geometry_column:
-            raise ValueError("Network file must have a geometry column")
-
         if center is None:
-            logger.info("No center provided, loading full network")
+            # Load minimal sample for metadata operations
+            self.con.execute(f"""
+                CREATE OR REPLACE VIEW {self._network_table_name} AS
+                SELECT * FROM read_parquet('{self._db_path}', hive_partitioning=false)
+                LIMIT 1000
+            """)
             self._is_loaded = True
             return self._network_table_name
-        # Calculate buffer distance
-        if buffer_radius is not None:
-            buffer_distance = buffer_radius
-        else:
-            # Convert travel time to distance
-            # speed_kmh * 1000 / 60 = meters per minute
-            buffer_distance = travel_time_minutes * (speed_kmh * 1000 / 60)
 
-        # Convert meters to degrees (approximate at the given latitude)
+        # Calculate buffer
+        if buffer_radius is None:
+            buffer_radius = travel_time_minutes * (speed_kmh * 1000 / 60)
 
+        # Calculate spatial bounds
         lat_rad = math.radians(center.lat)
-        meters_per_degree_lat = 111320  # roughly constant
-        meters_per_degree_lon = 111320 * math.cos(lat_rad)
-        buffer_degrees = buffer_distance / (
-            (meters_per_degree_lat + meters_per_degree_lon) / 2
-        )
+        cos_lat = max(math.cos(lat_rad), 0.01)
+        buffer_degrees = buffer_radius / (111320 * cos_lat)
 
-        logger.info(
-            f"Creating buffered network subset with buffer distance: {buffer_distance:.2f} m"
-        )
+        # Create temporary table name
+        subset_table_name = f"network_subset_{uuid.uuid4().hex[:8]}"
 
-        # Create buffered network
-        subset_table_name = f"routing_network_{uuid.uuid4().hex[:8]}"
-        # circular buffer around point
-        subset_query = f"""
-            CREATE TABLE {subset_table_name} AS
-            SELECT t.*
-            FROM {self._network_table_name} t
-            WHERE ST_DWithin(
-                t.{self._meta.geometry_column},
-                ST_MakePoint({center.lon}, {center.lat}), {buffer_degrees}
+        start_time = time.time()
+
+        try:
+            # Check if we can use bounding box columns from existing metadata
+            bbox_cols = [col.name.lower() for col in self.metadata.columns]
+            has_bbox = (
+                any(col in bbox_cols for col in ["xmin", "minx"])
+                and any(col in bbox_cols for col in ["ymin", "miny"])
+                and any(col in bbox_cols for col in ["xmax", "maxx"])
+                and any(col in bbox_cols for col in ["ymax", "maxy"])
             )
-            """
 
-        start = time.time()
-        self.con.execute(subset_query)
-        elapsed = time.time() - start
+            if has_bbox:
+                # Use bounding box columns for fast filtering
+                query = f"""
+                    CREATE TABLE {subset_table_name} AS
+                    SELECT *
+                    FROM read_parquet('{self._db_path}', hive_partitioning=false)
+                    WHERE 
+                        xmin <= {center.lon + buffer_degrees}
+                        AND xmax >= {center.lon - buffer_degrees}
+                        AND ymin <= {center.lat + buffer_degrees}
+                        AND ymax >= {center.lat - buffer_degrees}
+                        AND ST_DWithin(
+                            geometry,
+                            ST_MakePoint({center.lon}, {center.lat}),
+                            {buffer_degrees}
+                        )
+                """
+            else:
+                # Fallback to spatial-only filtering
+                query = f"""
+                    CREATE TABLE {subset_table_name} AS
+                    SELECT *
+                    FROM read_parquet('{self._db_path}', hive_partitioning=false)
+                    WHERE ST_DWithin(
+                        geometry,
+                        ST_MakePoint({center.lon}, {center.lat}),
+                        {buffer_degrees}
+                    )
+                """
 
-        logger.info(f"Network subset created in {round(elapsed * 1000, 1)} ms")
-        self._is_loaded = True
+            self.con.execute(query)
 
-        return subset_table_name
+        except Exception as e:
+            logger.debug(f"Using fallback spatial filter: {e}")
+            # Fallback: Simple bounding box using geometry
+            query = f"""
+                CREATE TABLE {subset_table_name} AS
+                WITH buffered AS (
+                    SELECT *,
+                        ST_XMin(ST_Extent(geometry)) as xmin,
+                        ST_YMin(ST_Extent(geometry)) as ymin,
+                        ST_XMax(ST_Extent(geometry)) as xmax,
+                        ST_YMax(ST_Extent(geometry)) as ymax
+                    FROM read_parquet('{self._db_path}', hive_partitioning=false)
+                    WHERE ST_DWithin(
+                        geometry,
+                        ST_MakePoint({center.lon}, {center.lat}),
+                        {buffer_degrees * 2}  # Wider initial filter
+                    )
+                    GROUP BY ALL
+                )
+                SELECT * EXCLUDE (xmin, ymin, xmax, ymax)
+                FROM buffered
+                WHERE ST_DWithin(
+                    geometry,
+                    ST_MakePoint({center.lon}, {center.lat}),
+                    {buffer_degrees}
+                )
+            """
+            self.con.execute(query)
 
-    # Network Analysis Methods
-    def split_edge_at_point_with_subset(
-        self,
-        point: Coordinates,
-        network_buffer_radius: float = 1000.0,
-        max_search_radius_m: float = 20.0,
-    ) -> tuple[str, Metadata]:
-        """
-        Loads a network subset around a point and splits the nearest edge.
+        elapsed = time.time() - start_time
 
-        This is memory-efficient as it only loads the network within the buffer radius.
+        # Create spatial index on the subset
+        try:
+            self.con.execute(f"""
+                CREATE INDEX idx_{subset_table_name}_spatial 
+                ON {subset_table_name} USING SPATIAL(geometry)
+            """)
+        except Exception as e:
+            logger.debug(f"Could not create spatial index: {e}")
 
-        Args:
-            point: Coordinates where to split
-            network_buffer_radius: Radius in meters to load network around the point
-            max_search_radius_m: Maximum search radius in meters for finding closest edge
-        Returns:
-            Tuple of (table_name, metadata) with split operation details
-        """
-        # Load only the network subset around the point
-        logger.info(
-            f"Loading network subset with {network_buffer_radius}m radius around point"
-        )
-        subset_table = self.load_network(
-            center=point, buffer_radius=network_buffer_radius
-        )
+        logger.debug(f"Loaded network subset in {elapsed:.3f}s")
 
-        # Now split on this subset
-        return self.split_edge_at_point(
-            point=point,
-            source_table=subset_table,
-            max_search_radius_m=max_search_radius_m,
-        )
+        self._is_loaded = True
+        return subset_table_name
 
-    def split_edge_at_point(
+    def prepare_routing_network(
         self,
-        point: Coordinates,
-        source_table: str = None,
-        max_search_radius_m: float = 100.0,
-    ) -> tuple[str, Metadata]:
+        start_point: Coordinates,
+        buffer_radius: Optional[float] = None,
+        travel_time_minutes: float = 90.0,
+        speed_kmh: float = 5.0,
+        output_path: Optional[str] = None,
+        subset_table: Optional[str] = None,
+    ) -> Tuple[str, int]:
         """
-        Finds the closest edge to a point, splits it, and creates a new network table.
+        Optimized preparation using pre-loaded network data.
 
         Args:
-            point: Coordinates where to start the route
-            source_table: Source table name (defaults to main network table)
-            max_search_radius_m: Maximum search radius in meters
-
-        Returns:
-            Tuple of (table_name, metadata) with split operation details in raw_meta
-        """
-        # Generate unique IDs
-        new_node_id = f"split_node_{uuid.uuid4().hex[:8]}"
-        split_table_name = f"split_network_{uuid.uuid4().hex[:8]}"
-
-        # Set source table if not provided
-        if source_table is None:
-            source_table = self._network_table_name
-
-        # Prepare geometry references
-        point_geom = f"ST_Point({point.lon}, {point.lat})"
-        geom_col = self._meta.geometry_column
-
-        # Convert meters to degrees for spatial search
-        # Approximation: 1 degree ≈ 111.32 km at equator
-        search_radius_deg = max_search_radius_m / 111320.0
-
-        # QUERY 1: Find closest edge with all needed info
-        find_query = f"""
-        WITH closest AS (
-            SELECT
-                edge_id,
-                source,
-                target,
-                length_m,
-                cost,
-                {geom_col},
-                ST_Distance({geom_col}, {point_geom}) as dist_deg,
-                ST_LineLocatePoint({geom_col}, {point_geom}) as frac
-            FROM {source_table}
-            WHERE ST_DWithin({geom_col}, {point_geom}, {search_radius_deg})
-            ORDER BY dist_deg
-            LIMIT 1
-        )
-        SELECT
-            *,
-            CASE WHEN frac BETWEEN 0.001 AND 0.999 THEN 1 ELSE 0 END as valid_split,
-            ST_X(ST_LineInterpolatePoint({geom_col}, frac)) as split_lon,
-            ST_Y(ST_LineInterpolatePoint({geom_col}, frac)) as split_lat
-        FROM closest;
+            subset_table: If provided, use this pre-loaded table instead of loading fresh data.
+                         This enables efficient reuse of loaded network data.
         """
+        start_time = time.time()
 
-        # Execute find query
-        find_start = time.time()
-        result = self.con.execute(find_query).fetchone()
-        find_elapsed = time.time() - find_start
-
-        if not result:
-            raise ValueError(
-                f"No edge found within {max_search_radius_m}m of point ({point.lat}, {point.lon})"
-            )
+        # Step 1: Load network data (or use pre-loaded)
+        if subset_table is None:
+            if buffer_radius is None:
+                buffer_radius = travel_time_minutes * (speed_kmh * 1000 / 60)
 
-        if result[-3] == 0:  # valid_split column
-            raise ValueError(
-                f"Edge found but split fraction {result[7]:.6f} is too close to endpoint"
+            subset_table = self.load_network(
+                center=start_point, buffer_radius=buffer_radius
             )
 
-        # Extract values from result
-        original_edge_id = result[0]
-        source_node = result[1]
-        target_node = result[2]
-        length_m = result[3]
-        cost_val = result[4]
-        dist_deg = result[6]
-        split_fraction = result[7]
-        split_lon = result[9]
-        split_lat = result[10]
-
-        # Convert distance to meters
-        distance_m = dist_deg * 111320.0
-
-        # QUERY 2: Split the edge efficiently
-        split_query = f"""
-        CREATE TABLE {split_table_name} AS
-
-        -- All edges except the one being split
-        SELECT *
-        FROM {source_table}
-        WHERE edge_id != '{original_edge_id}'
-
-        UNION ALL
-
-        -- Split into two parts: Source → New Node
-        SELECT
-            '{original_edge_id}_A' as edge_id,
-            source,
-            '{new_node_id}' as target,
-            ROUND(length_m * {split_fraction}, 3) as length_m,
-            ROUND(cost * {split_fraction}, 3) as cost,
-            ST_LineSubstring({geom_col}, 0.0, {split_fraction}) as {geom_col}
-        FROM {source_table}
-        WHERE edge_id = '{original_edge_id}'
+        # Spatial parameters for edge splitting
+        search_radius_deg = 200.0 / 111320.0  # 200m search radius
 
-        UNION ALL
+        # Output paths
+        if output_path is None:
+            output_path = (
+                f"{self._temp_dir}/routing_network_{uuid.uuid4().hex[:8]}.parquet"
+            )
 
-        -- Split into two parts: New Node → Target
-        SELECT
-            '{original_edge_id}_B' as edge_id,
-            '{new_node_id}' as source,
-            target,
-            ROUND(length_m * (1.0 - {split_fraction}), 3) as length_m,
-            ROUND(cost * (1.0 - {split_fraction}), 3) as cost,
-            ST_LineSubstring({geom_col}, {split_fraction}, 1.0) as {geom_col}
-        FROM {source_table}
-        WHERE edge_id = '{original_edge_id}';
-        """
+        # Generate unique IDs
+        new_node_id = (
+            abs(hash(f"split_{start_point.lat}_{start_point.lon}")) % 2147483647
+        )
 
-        # Execute split query
-        split_start = time.time()
-        self.con.execute(split_query)
-        split_elapsed = time.time() - split_start
+        # Step 2: Process the already-loaded network data for routing
+        try:
+            # Create routing-ready network with edge splitting
+            self.con.execute(f"""
+                CREATE TEMP TABLE temp_split_result AS
+                WITH
+                -- Find closest edge to split (working on pre-loaded data)
+                point_ref AS (
+                    SELECT ST_MakePoint({start_point.lon}, {start_point.lat})::GEOMETRY as search_point
+                ),
+                closest AS (
+                    SELECT b.*,
+                        ST_Distance(b.geometry::GEOMETRY, p.search_point) as dist,
+                        ST_LineLocatePoint(b.geometry::GEOMETRY, p.search_point) as frac
+                    FROM {subset_table} b, point_ref p
+                    WHERE ST_DWithin(b.geometry::GEOMETRY, p.search_point, {search_radius_deg})
+                    ORDER BY dist
+                    LIMIT 1
+                ),
+                -- Generate split edges
+                split_edges AS (
+                    -- Edges not being split
+                    SELECT 
+                        edge_id,
+                        source,
+                        target,
+                        length_m,
+                        geometry
+                    FROM {subset_table}
+                    WHERE edge_id NOT IN (SELECT edge_id FROM closest)
+
+                    UNION ALL
+
+                    -- First part of split edge (if valid split)
+                    SELECT 
+                        edge_id || '_A' as edge_id,
+                        source,
+                        {new_node_id} as target,
+                        ROUND(length_m * frac, 3) as length_m,
+                        ST_LineSubstring(geometry::GEOMETRY, 0.0, frac) as geometry
+                    FROM closest
+                    WHERE frac BETWEEN 0.001 AND 0.999
+
+                    UNION ALL
+
+                    -- Second part of split edge (if valid split)
+                    SELECT 
+                        edge_id || '_B' as edge_id,
+                        {new_node_id} as source,
+                        target,
+                        ROUND(length_m * (1.0 - frac), 3) as length_m,
+                        ST_LineSubstring(geometry::GEOMETRY, frac, 1.0) as geometry
+                    FROM closest
+                    WHERE frac BETWEEN 0.001 AND 0.999
+                )
+                -- Final selection with renumbered edge IDs
+                SELECT 
+                    CAST(ROW_NUMBER() OVER (ORDER BY edge_id) AS INTEGER) as edge_id,
+                    CAST(source AS INTEGER) as source,
+                    CAST(target AS INTEGER) as target,
+                    length_m,
+                    geometry
+                FROM split_edges
+            """)
+
+            # Step 3: Export to parquet with geometry converted to WKT for Rust lib
+            self.con.execute(f"""
+                COPY (SELECT
+                    edge_id,
+                    source,
+                    target,
+                    length_m,
+                    ST_AsText(geometry) as geometry
+                FROM temp_split_result)
+                TO '{output_path}' (FORMAT PARQUET)
+            """)
+
+            # Step 4: Clean up
+            self.con.execute("DROP TABLE IF EXISTS temp_split_result")
 
-        logger.info(
-            f"Edge '{original_edge_id}' split at {split_fraction:.3%} "
-            f"(~{distance_m:.1f}m from request) → Node '{new_node_id}' "
-            f"[Table: {split_table_name}] in {find_elapsed + split_elapsed:.3f}s"
-        )
+        except Exception as e:
+            logger.error(f"Failed to prepare routing network: {e}")
+            raise
 
-        # 2. METADATA
-        split_meta = Metadata(
-            geometry_column=self._meta.geometry_column,
-            raw_meta={
-                "source_table": source_table,
-                "split_operation": {
-                    "artificial_node_id": new_node_id,
-                    "original_edge": original_edge_id,
-                    "split_position": {
-                        "fraction": split_fraction,
-                        "request_point": {"lat": point.lat, "lon": point.lon},
-                        "actual_point": {"lat": split_lat, "lon": split_lon},
-                    },
-                    "edge_properties": {
-                        "original_length_m": length_m,
-                        "part_a_length_m": round(length_m * split_fraction, 3),
-                        "part_b_length_m": round(length_m * (1 - split_fraction), 3),
-                        "original_cost": cost_val,
-                        "source_node": source_node,
-                        "target_node": target_node,
-                    },
-                    "search_params": {
-                        "max_radius_m": max_search_radius_m,
-                        "search_radius_deg": search_radius_deg,
-                        "actual_distance_m": round(distance_m, 3),
-                    },
-                    "performance": {
-                        "find_query_ms": round(find_elapsed * 1000, 1),
-                        "split_query_ms": round(split_elapsed * 1000, 1),
-                        "total_ms": round((find_elapsed + split_elapsed) * 1000, 1),
-                    },
-                },
-            },
+        elapsed = time.time() - start_time
+        logger.debug(
+            f"Routing network ready in {elapsed:.3f}s, start node: {new_node_id}"
         )
 
-        # 3. VALIDATION WARNINGS
-        if split_fraction < SPLIT_EPSILON:
-            logger.warning(
-                f"Split at start of edge (fraction={split_fraction:.6f}). "
-                f"Consider using existing node '{source_node}' instead of '{new_node_id}'."
-            )
-        elif split_fraction > 1.0 - SPLIT_EPSILON:
-            logger.warning(
-                f"Split at end of edge (fraction={split_fraction:.6f}). "
-                f"Consider using existing node '{target_node}' instead of '{new_node_id}'."
-            )
-
-        return split_table_name, split_meta
+        return output_path, new_node_id
 
     def interpolate_long_edges(
         self,
         max_edge_length: float,
         base_table: str = None,
         interpolation_distance: float = None,
-        include_stats: bool = False,
-    ) -> tuple[str, Metadata]:
+    ) -> Tuple[str, Metadata]:
         """
-        Main function - creates interpolated table.
-        Stats are optional for performance.
+        Interpolate long edges by splitting them into smaller segments.
         """
-        source_table = base_table or self.network_table_name
+        if base_table is None:
+            self._ensure_loaded()
+            base_table = self._network_table_name
+
+        source_table = base_table
         interpolated_table = f"interpolated_network_{uuid.uuid4().hex[:8]}"
 
         if interpolation_distance is None:
@@ -417,6 +324,14 @@ def interpolate_long_edges(
             FROM {source_table}
             WHERE length_m > {max_edge_length}
         ),
+        segments_numbered AS (
+            SELECT le.*, s.segment_id
+            FROM long_edges le
+            CROSS JOIN (
+                VALUES (1), (2), (3), (4), (5), (6), (7), (8), (9), (10)
+            ) s(segment_id)
+            WHERE s.segment_id <= le.num_segments
+        ),
         interpolated_segments AS (
             SELECT
                 edge_id || '_seg_' || CAST(segment_id AS VARCHAR) as edge_id,
@@ -429,20 +344,18 @@ def interpolate_long_edges(
                     ELSE 'interp_' || edge_id || '_' || CAST(segment_id AS VARCHAR)
                 END as target,
                 length_m / num_segments as length_m,
-                cost / num_segments as cost,
                 ST_LineSubstring(
-                    {self._meta.geometry_column},
+                    geometry,
                     (segment_id - 1.0) / num_segments,
                     segment_id / num_segments
-                ) as {self._meta.geometry_column}
-            FROM long_edges
-            CROSS JOIN generate_series(1, num_segments) as t(segment_id)
+                ) as geometry
+            FROM segments_numbered
         )
-        SELECT edge_id, source, target, length_m, cost, {self._meta.geometry_column}
+        SELECT edge_id, source, target, length_m, geometry
         FROM {source_table}
         WHERE length_m <= {max_edge_length}
         UNION ALL
-        SELECT edge_id, source, target, length_m, cost, {self._meta.geometry_column}
+        SELECT edge_id, source, target, length_m, geometry
         FROM interpolated_segments
         ORDER BY edge_id;
         """
@@ -450,14 +363,14 @@ def interpolate_long_edges(
         self.con.execute(query)
         processing_time = time.time() - start_time
 
-        logger.info(
-            f"MAIN Interpolated network created: {interpolated_table} "
-            f"in {processing_time:.3f}s"
-        )
+        logger.debug(f"Network interpolation completed in {processing_time:.3f}s")
 
         # Create metadata
         meta = Metadata(
-            geometry_column=self._meta.geometry_column,
+            geometry_column="geometry",
+            geometry_type="LineString",
+            crs=None,
+            columns=self.metadata.columns,
             raw_meta={
                 "interpolation_operation": {
                     "table_name": interpolated_table,
@@ -469,94 +382,109 @@ def interpolate_long_edges(
                 }
             },
         )
-        if include_stats:
-            stats = self._get_interpolation_stats(table_name=interpolated_table)
-            meta.raw_meta["interpolation_operation"].update(stats)
 
         return interpolated_table, meta
 
-    def _get_interpolation_stats(
-        self,
-        table_name: str,
-    ) -> Dict[str, Any]:
-        """Get statistics about the interpolation operation."""
-        stats_query = f"""
-        WITH stats AS (
-            SELECT
-                COUNT(*) as total_edges,
-                COUNT(*) FILTER (WHERE edge_id LIKE '%_seg_%') as segments_created,
-                MAX(length_m) as max_segment_length,
-                SUM(length_m) as total_length
-            FROM {table_name}
-        ),
-        node_stats AS (
-            SELECT
-                COUNT(DISTINCT source) + COUNT(DISTINCT target) as total_nodes,
-                COUNT(DISTINCT source) FILTER (WHERE source LIKE 'interp_%') +
-                COUNT(DISTINCT target) FILTER (WHERE target LIKE 'interp_%') as new_nodes
-            FROM {table_name}
-        )
-        SELECT
-            s.total_edges,
-            s.segments_created,
-            s.max_segment_length,
-            s.total_length,
-            ns.new_nodes,
-            ns.total_nodes
-        FROM stats s, node_stats ns;
+    def cleanup(self) -> None:
         """
+        Closes the DuckDB connection and cleans up temporary resources.
+        This is called automatically by the context manager.
+        """
+        # 1. Close the DuckDB connection
+        if hasattr(self, "con") and self.con:
+            try:
+                self.con.close()
+                logger.debug("DuckDB connection closed")
+            except Exception as e:
+                logger.warning(f"Error closing DuckDB connection: {e}")
+
+        # 2. Clean up the temporary directory and any DuckDB files
+        if hasattr(self, "_temp_dir") and self._temp_dir:
+            try:
+                import os
+                import shutil
+
+                temp_path = Path(self._temp_dir)
+                if temp_path.exists():
+                    # Look for any DuckDB journal/WAL files in the temp directory
+                    for db_file in temp_path.glob("*.wal"):
+                        try:
+                            os.remove(db_file)
+                            logger.debug(f"Removed DuckDB WAL file: {db_file}")
+                        except Exception as e:
+                            logger.debug(f"Could not remove WAL file {db_file}: {e}")
+
+                    # Remove the entire temp directory
+                    shutil.rmtree(temp_path, ignore_errors=False)
+                    logger.debug(f"Cleaned up temporary directory: {temp_path}")
+            except Exception as e:
+                logger.warning(f"Failed to clean up temporary directory: {e}")
+
+    # ==================== PRIVATE HELPER METHODS ====================
+    # Internal methods that support the public API
+
+    def _setup_duckdb_extensions(self) -> None:
+        """Configure DuckDB with optimized settings and error handling."""
+        extensions = [
+            "INSTALL spatial; LOAD spatial;",
+            "INSTALL parquet; LOAD parquet;",
+        ]
+
+        settings = [
+            "SET threads TO 4;",
+            "SET enable_progress_bar=false;",
+            "SET memory_limit='2GB';",  # Reasonable memory limit
+        ]
+
+        for ext in extensions + settings:
+            try:
+                self.con.execute(ext)
+            except Exception as e:
+                logger.debug(f"DuckDB setup: {ext} - {e}")
+
+    def _load_metadata_only(self) -> Metadata:
+        """
+        Load only metadata from parquet file without loading data.
+        Optimized for speed with minimal column scanning.
+        """
+        try:
+            cols = self.con.execute(f"""
+                DESCRIBE SELECT * FROM read_parquet('{self._db_path}', hive_partitioning=false) LIMIT 0
+            """).fetchall()
 
-        stats_result = self.con.execute(stats_query).fetchone()
-
-        return {
-            "final_edge_count": stats_result[0],
-            "segments_created": stats_result[1],
-            "max_segment_length_m": round(stats_result[2], 2),
-            "total_length_m": round(stats_result[3], 2),
-            "new_intermediate_nodes": stats_result[4],
-            "total_nodes": stats_result[5],
-        }
+            # assume 'geometry' column exists
+            geometry_column = "geometry"
+            # Each col is a tuple: (name, type, null, key, default, extra)
+            for col in cols:
+                col_name = col[0]
+                if col_name.lower() == "geometry":
+                    geometry_column = col_name
+                    break
+
+            # Skip geometry type detection for performance
+            return Metadata(
+                geometry_column=geometry_column,
+                geometry_type="LineString",
+                crs=None,
+                columns=[ColumnMeta(name=c[0], type=c[1], nullable=True) for c in cols],
+                raw_meta={"source_path": str(self._db_path), "fast_load": True},
+            )
 
-    # File I/O Methods
-    def save_network(
-        self,
-        table_name: str,
-        output_path: str | None = None,
-        format: str = "PARQUET",
-    ) -> str:
-        import tempfile
+        except Exception as e:
+            logger.error(f"Failed to load metadata: {e}")
+            raise
 
-        def quote_ident(name: str) -> str:
-            return '"' + name.replace('"', '""') + '"'
+    def _ensure_loaded(self) -> None:
+        """Ensure network is loaded."""
+        if not self._is_loaded:
+            # Load minimal data for operations
+            self.load_network()
 
-        format_upper = format.upper()
-        table = quote_ident(table_name)
+    # ==================== CONTEXT MANAGER ====================
+    # Special methods for context management
 
-        if output_path is None:
-            suffix = ".parquet" if format_upper == "PARQUET" else ".gpkg"
-            with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
-                output_path = tmp.name
-
-        if format_upper == "PARQUET":
-            self.con.execute(
-                f"""
-                COPY {table} TO '{output_path}'
-                (
-                    FORMAT PARQUET,
-                    COMPRESSION ZSTD,
-                    ROW_GROUP_SIZE 1000000
-                )
-                """
-            )
-        else:
-            self.con.execute(
-                f"""
-                COPY {table} TO '{output_path}'
-                (
-                    FORMAT GDAL,
-                    DRIVER '{format_upper}'
-                )
-                """
-            )
+    def __enter__(self) -> "InMemoryNetworkProcessor":
+        return self
 
-        return output_path
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.cleanup()
diff --git a/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py b/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
deleted file mode 100644
index ebe155919..000000000
--- a/packages/python/goatlib/tests/benchmarks/benchmark_network_memory_usage.py
+++ /dev/null
@@ -1,335 +0,0 @@
-import gc
-import logging
-import time
-from pathlib import Path
-
-try:
-    import psutil
-
-    PSUTIL_AVAILABLE = True
-except ImportError:
-    PSUTIL_AVAILABLE = False
-
-import pytest
-from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
-from goatlib.routing.schemas.base import Coordinates
-
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
-)
-
-
-# --- Helper Functions ---
-def get_memory_mb() -> dict[str, float]:
-    process = psutil.Process()
-    mem_info = process.memory_info()
-    return {"rss": mem_info.rss / (1024**2), "vms": mem_info.vms / (1024**2)}
-
-
-def print_memory(
-    stage: str, current: dict[str, float], baseline: dict[str, float]
-) -> None:
-    rss_delta = current["rss"] - baseline["rss"]
-    vms_delta = current["vms"] - baseline["vms"]
-    print(
-        f"{stage:<28} | RSS: {current['rss']:>7.1f} MB (+{rss_delta:6.1f}) | VMS: {current['vms']:>8.1f} MB (+{vms_delta:7.1f})"
-    )
-
-
-# --- Main Benchmark ---
-def run_lightweight_benchmark(network_path: str | None = None) -> None:
-    """Lightweight benchmark matching the original performance test."""
-    # Get network path from conftest fixture location if not provided
-    if network_path is None:
-        network_path = str(
-            Path(__file__).parent.parent / "data" / "network" / "network.parquet"
-        )
-
-    if not (PSUTIL_AVAILABLE and Path(network_path).exists()):
-        print("psutil or network file not available. Aborting benchmark.")
-        return
-
-    print("=" * 80)
-    print("🚀 Lightweight Network Processor: Performance Benchmark")
-    print("=" * 80)
-
-    gc.collect()
-    baseline_memory = get_memory_mb()
-    print(
-        f"Baseline                     | RSS: {baseline_memory['rss']:>7.1f} MB          | VMS: {baseline_memory['vms']:>8.1f} MB"
-    )
-
-    stages = []
-    total_time_start = time.perf_counter()
-
-    with InMemoryNetworkProcessor(network_path) as proc:
-        stages.append(("After Loading", get_memory_mb()))
-
-        # Load network (replaces _generate_table_name)
-        center = Coordinates(lat=48.1351, lon=11.5820)
-        subset_table = proc.load_network(center=center, buffer_radius=2000)
-        stages.append(("After Subset Creation", get_memory_mb()))
-
-        stats = proc.get_network_stats(subset_table)
-
-        # Test edge splitting
-        try:
-            split_point = Coordinates(lat=48.1370, lon=11.5760)
-            split_table, split_meta = proc.split_edge_at_point(
-                point=split_point,
-                source_table=subset_table,
-                max_search_radius_m=100.0,
-            )
-            stages.append(("After Edge Split", get_memory_mb()))
-
-            # Verify split worked
-            split_stats = proc.get_network_stats(split_table)
-            assert split_stats["edge_count"] == stats["edge_count"] + 1
-
-        except ValueError as e:
-            print(f"Split operation failed: {e}")
-            stages.append(("After Failed Split", get_memory_mb()))
-
-    total_time_end = time.perf_counter()
-    gc.collect()
-    stages.append(("Final (After Context Exit)", get_memory_mb()))
-
-    # Print all stages
-    for stage_name, memory_data in stages:
-        print_memory(stage_name, memory_data, baseline_memory)
-
-    # Summary
-    total_duration = total_time_end - total_time_start
-    peak_rss = max(stage_data["rss"] for _, stage_data in stages)
-    print("-" * 80)
-    print("📊 Summary:")
-    print(f"Total processing time: {total_duration:.3f} seconds")
-    print(f"Network size: {stats['edge_count']:,} edges")
-    print(
-        f"Peak Physical Memory (RSS) Increase: {peak_rss - baseline_memory['rss']:.1f} MB"
-    )
-    print(f"Processing Rate: {stats['edge_count'] / total_duration:,.0f} edges/second")
-    print("=" * 80)
-
-
-def run_full_benchmark(network_path: str | None = None):
-    """Full benchmark including interpolation and advanced features."""
-    if network_path is None:
-        network_path = str(
-            Path(__file__).parent.parent / "data" / "network" / "network.parquet"
-        )
-
-    if not (PSUTIL_AVAILABLE and Path(network_path).exists()):
-        print("psutil or network file not available. Aborting benchmark.")
-        return
-
-    print("=" * 80)
-    print("🧠 Full Network Processor: Complete Workflow Benchmark")
-    print("=" * 80)
-
-    gc.collect()
-    baseline_memory = get_memory_mb()
-    print(
-        f"Baseline                     | RSS: {baseline_memory['rss']:>7.1f} MB          | VMS: {baseline_memory['vms']:>8.1f} MB"
-    )
-
-    stages = []
-    total_time_start = time.perf_counter()
-
-    with InMemoryNetworkProcessor(network_path) as proc:
-        stages.append(("After Loading", get_memory_mb()))
-
-        # 1. Load network subset
-        center = Coordinates(lat=48.1351, lon=11.5820)
-        subset_table = proc.load_network(center=center, buffer_radius=5000)
-        subset_stats = proc.get_network_stats(subset_table)
-        stages.append(("After Subset Creation", get_memory_mb()))
-        print(f"📊 Subset: {subset_stats['edge_count']:,} edges")
-
-        # 2. Split edge at point
-        split_point = Coordinates(lat=48.1370, lon=11.5760)
-        split_table, split_meta = proc.split_edge_at_point(
-            point=split_point,
-            source_table=subset_table,
-            max_search_radius_m=100.0,
-        )
-        split_stats = proc.get_network_stats(split_table)
-        stages.append(("After Edge Split", get_memory_mb()))
-        print(f"✂️  Split: {split_stats['edge_count']:,} edges (+1)")
-
-        # 3. Interpolate long edges
-        interp_table, interp_meta = proc.interpolate_long_edges(
-            max_edge_length=50.0,
-            base_table=split_table,
-            include_stats=True,
-        )
-        interp_stats = proc.get_network_stats(interp_table)
-        stages.append(("After Interpolation", get_memory_mb()))
-        print(f"📐 Interpolated: {interp_stats['edge_count']:,} edges")
-
-        # 4. Test split with subset (combined operation)
-        combined_table, combined_meta = proc.split_edge_at_point_with_subset(
-            point=Coordinates(lat=48.1360, lon=11.5770),
-            network_buffer_radius=1000.0,
-            max_search_radius_m=50.0,
-        )
-        stages.append(("After Combined Split", get_memory_mb()))
-
-        # 5. Test apply_sql_query
-        sql_table = proc.apply_sql_query(
-            sql_query=f"""
-            SELECT * 
-            FROM {interp_table} 
-            WHERE length_m > 30 
-            AND edge_id NOT LIKE '%_s%'
-            """,
-            result_table="filtered_long",
-        )
-        stages.append(("After SQL Query", get_memory_mb()))
-
-    total_time_end = time.perf_counter()
-    gc.collect()
-    stages.append(("Final (After Cleanup)", get_memory_mb()))
-
-    # Print all stages
-    for stage_name, memory_data in stages:
-        print_memory(stage_name, memory_data, baseline_memory)
-
-    # Summary
-    total_duration = total_time_end - total_time_start
-    peak_rss = max(stage_data["rss"] for _, stage_data in stages)
-    print("-" * 80)
-    print("📊 Summary:")
-    print(f"Total processing time: {total_duration:.3f} seconds")
-    print(f"Original subset: {subset_stats['edge_count']:,} edges")
-    print(f"Final interpolated: {interp_stats['edge_count']:,} edges")
-    print(
-        f"Edge increase: {interp_stats['edge_count'] - subset_stats['edge_count']:,} edges"
-    )
-    print(
-        f"Peak Physical Memory (RSS) Increase: {peak_rss - baseline_memory['rss']:.1f} MB"
-    )
-    print(f"Operations/second: {5 / total_duration:.1f} ops/sec")  # 5 main operations
-    print("=" * 80)
-
-
-def run_performance_stress_test(network_path: str | None = None):
-    """Stress test with multiple operations."""
-    if network_path is None:
-        network_path = str(
-            Path(__file__).parent.parent / "data" / "network" / "network.parquet"
-        )
-
-    if not (PSUTIL_AVAILABLE and Path(network_path).exists()):
-        print("psutil or network file not available. Aborting benchmark.")
-        return
-
-    print("=" * 80)
-    print("⚡ Network Processor: Stress Test (Multiple Operations)")
-    print("=" * 80)
-
-    gc.collect()
-    baseline_memory = get_memory_mb()
-
-    with InMemoryNetworkProcessor(network_path) as proc:
-        center = Coordinates(lat=48.1351, lon=11.5820)
-
-        # Create multiple subsets
-        tables = []
-        start = time.perf_counter()
-
-        for i in range(3):
-            # Vary buffer sizes
-            table = proc.load_network(center=center, buffer_radius=1000 + i * 2000)
-            tables.append(table)
-
-            # Split at slightly different points
-            split_point = Coordinates(
-                lat=48.1351 + (i * 0.001), lon=11.5820 + (i * 0.001)
-            )
-            split_table, _ = proc.split_edge_at_point(
-                point=split_point,
-                source_table=table,
-                max_search_radius_m=50.0,
-            )
-            tables.append(split_table)
-
-            # Interpolate with different thresholds
-            interp_table, _ = proc.interpolate_long_edges(
-                max_edge_length=30.0 + (i * 20),
-                base_table=split_table,
-                include_stats=False,
-            )
-            tables.append(interp_table)
-
-        end = time.perf_counter()
-
-        print(f"Created {len(tables)} tables in {end - start:.2f}s")
-        print(f"Average: {(end - start) / len(tables):.3f}s per table")
-
-        # Memory after many operations
-        current_memory = get_memory_mb()
-        print_memory("After Stress Test", current_memory, baseline_memory)
-
-    print("✅ Stress test completed - all tables should be cleaned up")
-
-
-# --- Pytest Version Using Conftest Fixture ---
-def test_benchmark_with_fixture(network_file: Path):
-    """Pytest version of the benchmark that uses the conftest network_file fixture."""
-    if not PSUTIL_AVAILABLE:
-        pytest.skip("psutil not available for memory monitoring")
-
-    run_lightweight_benchmark(str(network_file))
-
-
-def test_full_benchmark_with_fixture(network_file: Path):
-    """Full benchmark test."""
-    if not PSUTIL_AVAILABLE:
-        pytest.skip("psutil not available for memory monitoring")
-
-    run_full_benchmark(str(network_file))
-
-
-def test_table_tracking_benchmark(network_file: Path):
-    """Test table tracking and cleanup."""
-    if not PSUTIL_AVAILABLE:
-        pytest.skip("psutil not available for memory monitoring")
-
-    # Get initial table count
-    with InMemoryNetworkProcessor(str(network_file)) as proc:
-        initial_tables = proc.get_application_tables()
-        print(f"Initial tables: {len(initial_tables)}")
-
-        # Create tables
-        center = Coordinates(lat=48.1351, lon=11.5820)
-        table1 = proc.load_network(center=center, buffer_radius=1000)
-        table2, _ = proc.split_edge_at_point(
-            point=center,
-            source_table=table1,
-            max_search_radius_m=100.0,
-        )
-
-        # Memory usage
-        mem = get_memory_mb()
-        print(f"Memory with 2 tables: {mem['rss']:.1f} MB RSS")
-
-    # After context exit, tables should be cleaned
-    # (Can't verify without new connection, but memory should drop)
-    final_mem = get_memory_mb()
-    print(f"Final memory after cleanup: {final_mem['rss']:.1f} MB RSS")
-
-
-if __name__ == "__main__":
-    print("Running lightweight benchmark...")
-    run_lightweight_benchmark()
-
-    print("\n" + "=" * 80 + "\n")
-
-    print("Running full workflow benchmark...")
-    run_full_benchmark()
-
-    print("\n" + "=" * 80 + "\n")
-
-    print("Running stress test...")
-    run_performance_stress_test()
diff --git a/packages/python/goatlib/tests/benchmarks/test_network_performance.py b/packages/python/goatlib/tests/benchmarks/test_network_performance.py
new file mode 100644
index 000000000..e6ec0c02d
--- /dev/null
+++ b/packages/python/goatlib/tests/benchmarks/test_network_performance.py
@@ -0,0 +1,400 @@
+#!/usr/bin/env python3
+import gc
+import logging
+import os
+import time
+from pathlib import Path
+
+import psutil
+from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
+from goatlib.routing.schemas.base import Coordinates
+
+# Set up logging
+logging.basicConfig(
+    level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+def test_benchmark_split_architecture():
+    """Benchmark the split architecture benefits."""
+    test_file = Path(__file__).parent.parent / "data" / "network" / "network.parquet"
+
+    if not test_file.exists():
+        logger.error(f"Test file not found: {test_file}")
+        return
+
+    start_point = Coordinates(lat=48.1351, lon=11.5820)
+
+    with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
+        # Traditional approach (load every time)
+        traditional_times = []
+
+        for i in range(3):
+            gc.collect()
+            t1 = time.perf_counter()
+            output_path, node_id = proc.prepare_routing_network(
+                start_point=start_point, buffer_radius=400.0
+            )
+            t2 = time.perf_counter()
+            elapsed = (t2 - t1) * 1000
+            traditional_times.append(elapsed)
+
+            # Cleanup
+            import os
+
+            if os.path.exists(output_path):
+                os.unlink(output_path)
+
+        avg_traditional = sum(traditional_times) / len(traditional_times)
+
+        # Split approach (load once, reuse)
+        # Load once
+        gc.collect()
+        t_load_start = time.perf_counter()
+        subset_table = proc.load_network(center=start_point, buffer_radius=400.0)
+        t_load_end = time.perf_counter()
+        load_time = (t_load_end - t_load_start) * 1000
+
+        # Reuse loaded data multiple times
+        reuse_times = []
+        for i in range(3):
+            gc.collect()
+            t1 = time.perf_counter()
+            output_path, node_id = proc.prepare_routing_network(
+                start_point=start_point,
+                buffer_radius=400.0,
+                subset_table=subset_table,  # Reuse!
+            )
+            t2 = time.perf_counter()
+            elapsed = (t2 - t1) * 1000
+            reuse_times.append(elapsed)
+
+            # Cleanup
+            import os
+
+            if os.path.exists(output_path):
+                os.unlink(output_path)
+
+        avg_reuse = sum(reuse_times) / len(reuse_times)
+
+        # Calculate benefits
+        total_traditional = avg_traditional * 3
+        total_split = load_time + (avg_reuse * 3)
+        savings = total_traditional - total_split
+
+        logger.info(
+            f"Split architecture: {savings:.1f}ms savings ({savings/total_traditional*100:.1f}%)"
+        )
+        logger.info(
+            f"  Traditional: {avg_traditional:.1f}ms avg | Split: Load {load_time:.1f}ms + Routing {avg_reuse:.1f}ms"
+        )
+
+        if avg_reuse < 10:
+            logger.info(f"✅ EXCELLENT: Routing logic only {avg_reuse:.1f}ms!")
+        elif avg_reuse < 20:
+            logger.info(f"✅ VERY GOOD: Routing logic {avg_reuse:.1f}ms")
+        else:
+            logger.info(f"⚠ COULD IMPROVE: Routing logic {avg_reuse:.1f}ms")
+
+
+def test_benchmark_buffer_sizes():
+    """Benchmark different buffer sizes."""
+    test_file = Path(__file__).parent.parent / "data" / "network" / "network.parquet"
+
+    if not test_file.exists():
+        logger.error(f"Test file not found: {test_file}")
+        return
+
+    start_point = Coordinates(lat=48.1351, lon=11.5820)
+
+    buffer_sizes = [200, 400, 800, 1200, 1600]  # meters
+
+    for buffer_m in buffer_sizes:
+        times = []
+        edge_counts = []
+
+        for run in range(3):
+            gc.collect()
+
+            with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
+                t1 = time.perf_counter()
+                output_path, node_id = proc.prepare_routing_network(
+                    start_point=start_point, buffer_radius=buffer_m
+                )
+                t2 = time.perf_counter()
+
+                elapsed = (t2 - t1) * 1000
+                times.append(elapsed)
+
+                # Get edge count from output
+                import duckdb
+
+                con = duckdb.connect()
+                con.execute("INSTALL spatial; LOAD spatial;")
+                edge_count = con.execute(
+                    f"SELECT COUNT(*) FROM read_parquet('{output_path}')"
+                ).fetchone()[0]
+                edge_counts.append(edge_count)
+                con.close()
+
+                # Cleanup
+                import os
+
+                if os.path.exists(output_path):
+                    os.unlink(output_path)
+
+        avg_time = sum(times) / len(times)
+        avg_edges = sum(edge_counts) / len(edge_counts)
+        min_time = min(times)
+        max_time = max(times)
+
+        if avg_time < 100:
+            status = "✅"
+        elif avg_time < 150:
+            status = "✓"
+        else:
+            status = "⚠"
+
+        logger.info(
+            f"{status} {buffer_m}m: {avg_time:.1f}ms avg ({min_time:.1f}-{max_time:.1f}ms), {avg_edges:.0f} edges"
+        )
+
+
+def test_benchmark_artificial_node_only():
+    """Benchmark just the artificial node creation logic."""
+    test_file = Path(__file__).parent.parent / "data" / "network" / "network.parquet"
+
+    if not test_file.exists():
+        logger.error(f"Test file not found: {test_file}")
+        return
+
+    start_point = Coordinates(lat=48.1351, lon=11.5820)
+
+    with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
+        # Load network once
+        subset_table = proc.load_network(center=start_point, buffer_radius=400.0)
+
+        # Test artificial node creation multiple times
+        times = []
+        for i in range(10):
+            gc.collect()
+
+            search_radius_deg = 200.0 / 111320.0
+            new_node_id = (
+                abs(hash(f"split_{start_point.lat}_{start_point.lon}_{i}")) % 2147483647
+            )
+
+            t1 = time.perf_counter()
+
+            # Core artificial node creation
+            proc.con.execute(f"""
+                DROP TABLE IF EXISTS temp_artificial_benchmark;
+                CREATE TEMP TABLE temp_artificial_benchmark AS
+                WITH 
+                point_ref AS (
+                    SELECT ST_MakePoint({start_point.lon}, {start_point.lat})::GEOMETRY as search_point
+                ),
+                closest AS (
+                    SELECT *,
+                        ST_Distance(geometry::GEOMETRY, p.search_point) as dist,
+                        ST_LineLocatePoint(geometry::GEOMETRY, p.search_point) as frac
+                    FROM {subset_table}, point_ref p
+                    WHERE ST_DWithin(geometry::GEOMETRY, p.search_point, {search_radius_deg})
+                    ORDER BY dist
+                    LIMIT 1
+                ),
+                split_result AS (
+                    SELECT edge_id, source, target, length_m, geometry
+                    FROM {subset_table}
+                    WHERE edge_id NOT IN (SELECT edge_id FROM closest)
+                    
+                    UNION ALL
+                    
+                    SELECT 
+                        c.edge_id,
+                        c.source,
+                        {new_node_id} as target,
+                        c.length_m * c.frac as length_m,
+                        ST_LineSubstring(c.geometry::GEOMETRY, 0, c.frac) as geometry
+                    FROM closest c
+                    
+                    UNION ALL
+                    
+                    SELECT 
+                        c.edge_id + 1000000 as edge_id,
+                        {new_node_id} as source, 
+                        c.target,
+                        c.length_m * (1 - c.frac) as length_m,
+                        ST_LineSubstring(c.geometry::GEOMETRY, c.frac, 1) as geometry
+                    FROM closest c
+                )
+                SELECT * FROM split_result;
+            """)
+
+            t2 = time.perf_counter()
+            elapsed = (t2 - t1) * 1000
+            times.append(elapsed)
+
+        avg_time = sum(times) / len(times)
+        min_time = min(times)
+        max_time = max(times)
+
+        if avg_time < 5:
+            status = "✅"
+        elif avg_time < 10:
+            status = "✓"
+        else:
+            status = "⚠"
+
+        logger.info(
+            f"{status} Artificial node: {avg_time:.2f}ms avg (range: {min_time:.2f}-{max_time:.2f}ms)"
+        )
+
+
+def test_benchmark_memory_and_performance():
+    """Comprehensive benchmark combining memory usage and performance metrics."""
+    test_file = Path(__file__).parent.parent / "data" / "network" / "network.parquet"
+
+    if not test_file.exists():
+        logger.error(f"Test file not found: {test_file}")
+        return
+
+    # Get current process for memory tracking
+    process = psutil.Process(os.getpid())
+
+    def get_memory_info():
+        """Get current memory usage in MB."""
+        mem_info = process.memory_info()
+        return {
+            "rss_mb": mem_info.rss / 1024 / 1024,
+            "vms_mb": mem_info.vms / 1024 / 1024,
+            "available_mb": psutil.virtual_memory().available / 1024 / 1024,
+            "percent": psutil.virtual_memory().percent,
+        }
+
+    start_point = Coordinates(lat=48.1351, lon=11.5820)
+    buffer_sizes = [400, 800, 1200]  # Different buffer sizes to test scaling
+
+    results = []
+
+    # Baseline memory
+    gc.collect()
+    baseline = get_memory_info()
+
+    for buffer_m in buffer_sizes:
+        # Test with fresh processor instances
+        gc.collect()
+        before_test = get_memory_info()
+
+        performance_times = []
+        peak_memory = before_test["rss_mb"]
+
+        for run in range(3):
+            gc.collect()
+            run_start_memory = get_memory_info()
+
+            with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
+                # Measure both time and memory for complete operation
+                t1 = time.perf_counter()
+
+                # Load network
+                subset_table = proc.load_network(
+                    center=start_point, buffer_radius=buffer_m
+                )
+
+                after_load = get_memory_info()
+                peak_memory = max(peak_memory, after_load["rss_mb"])
+
+                # Prepare routing network
+                output_path, node_id = proc.prepare_routing_network(
+                    start_point=start_point,
+                    buffer_radius=buffer_m,
+                    subset_table=subset_table,
+                )
+
+                t2 = time.perf_counter()
+                after_prep = get_memory_info()
+                peak_memory = max(peak_memory, after_prep["rss_mb"])
+
+                elapsed_ms = (t2 - t1) * 1000
+                performance_times.append(elapsed_ms)
+
+                # Get network statistics from output
+                import duckdb
+
+                temp_con = duckdb.connect()
+                temp_con.execute("INSTALL spatial; LOAD spatial;")
+                edge_count = temp_con.execute(
+                    f"SELECT COUNT(*) FROM read_parquet('{output_path}')"
+                ).fetchone()[0]
+                temp_con.close()
+
+                # Cleanup
+                if os.path.exists(output_path):
+                    os.unlink(output_path)
+
+        # Calculate statistics
+        avg_time = sum(performance_times) / len(performance_times)
+        min_time = min(performance_times)
+        max_time = max(performance_times)
+        memory_increase = peak_memory - baseline["rss_mb"]
+
+        results.append(
+            {
+                "buffer_m": buffer_m,
+                "avg_time_ms": avg_time,
+                "min_time_ms": min_time,
+                "max_time_ms": max_time,
+                "peak_memory_mb": peak_memory,
+                "memory_increase_mb": memory_increase,
+                "edge_count": edge_count,
+            }
+        )
+
+        # Memory efficiency calculation
+        memory_per_edge = (
+            memory_increase / edge_count * 1024 if edge_count > 0 else 0
+        )  # KB per edge
+
+        # Performance vs memory assessment
+        if avg_time < 100 and memory_increase < 100:
+            efficiency = "✅"
+        elif avg_time < 150 and memory_increase < 150:
+            efficiency = "✓"
+        else:
+            efficiency = "⚠"
+
+        logger.info(
+            f"{efficiency} {buffer_m}m: {avg_time:.1f}ms ({min_time:.1f}-{max_time:.1f}ms), {memory_increase:.1f}MB, {memory_per_edge:.1f}KB/edge"
+        )
+
+    # Final cleanup check
+    gc.collect()
+    time.sleep(0.2)
+    final = get_memory_info()
+    total_cleanup = final["rss_mb"] - baseline["rss_mb"]
+
+    peak_increase = max(r["memory_increase_mb"] for r in results)
+    logger.info(
+        f"Memory: Peak {peak_increase:.1f}MB, Cleanup {total_cleanup:+.1f}MB, Available {final['available_mb']:.1f}MB"
+    )
+
+    # Scalability analysis
+    if len(results) >= 2:
+        # Check if performance scales reasonably with buffer size
+        small_buffer = results[0]
+        large_buffer = results[-1]
+
+        time_scale_factor = large_buffer["avg_time_ms"] / small_buffer["avg_time_ms"]
+        memory_scale_factor = (
+            large_buffer["memory_increase_mb"] / small_buffer["memory_increase_mb"]
+        )
+        edge_scale_factor = large_buffer["edge_count"] / small_buffer["edge_count"]
+
+        time_status = "✅" if time_scale_factor < edge_scale_factor * 1.5 else "⚠"
+        memory_status = "✅" if memory_scale_factor < edge_scale_factor * 2 else "⚠"
+
+        logger.info(
+            f"Scalability: {time_status} Time {time_scale_factor:.1f}x, {memory_status} Memory {memory_scale_factor:.1f}x, Edges {edge_scale_factor:.1f}x"
+        )
diff --git a/packages/python/goatlib/tests/integration/network/test_interpolation.py b/packages/python/goatlib/tests/integration/network/test_interpolation.py
deleted file mode 100644
index 38611d16f..000000000
--- a/packages/python/goatlib/tests/integration/network/test_interpolation.py
+++ /dev/null
@@ -1,273 +0,0 @@
-import logging
-from pathlib import Path
-
-from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
-from goatlib.routing.schemas.base import Coordinates
-
-logger = logging.getLogger(__name__)
-
-
-def test_interpolate_point_on_edge(network_file: Path) -> None:
-    """Test interpolating a point along an edge with comprehensive validation."""
-    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
-        # Try to split
-        split_table, split_meta = proc.split_edge_at_point_with_subset(
-            point=Coordinates(lat=48.137154, lon=11.576124),
-            network_buffer_radius=500.0,
-            max_search_radius_m=100.0,
-        )
-
-        split_stats = proc.get_network_stats(split_table)
-        logger.info(f"Split network: {split_stats['edge_count']} edges")
-
-        # Interpolate long edges (> 50m)
-        new_table, new_meta = proc.interpolate_long_edges(
-            base_table=split_table,
-            max_edge_length=10.0,
-            include_stats=True,
-        )
-
-        new_stats = proc.get_network_stats(new_table)
-        logger.info(f"Interpolated network: {new_stats['edge_count']} edges")
-
-        # Basic assertion
-        assert (
-            new_stats["edge_count"] >= split_stats["edge_count"]
-        ), f"Interpolation should increase edge count, but {new_stats['edge_count']} < {split_stats['edge_count']}"
-
-        # 1. CHECK: Metadata exists
-        assert (
-            split_meta.raw_meta.get("split_operation", {}) is not None
-        ), "Missing split metadata"
-        assert (
-            new_meta.raw_meta.get("interpolation_operation", {}) is not None
-        ), "Missing interpolation metadata"
-
-        # 2. CHECK: No edges longer than max threshold (with small tolerance)
-        max_allowed = 50.0 * 1.1  # 10% tolerance
-        max_edge_result = proc.con.execute(f"""
-            SELECT MAX(length_m) as max_length
-            FROM {new_table}
-        """).fetchone()
-
-        max_length = max_edge_result[0] if max_edge_result[0] else 0
-        assert (
-            max_length <= max_allowed
-        ), f"Found segment {max_length:.1f}m > max allowed {max_allowed:.1f}m"
-        logger.info(f"✓ Max segment length: {max_length:.1f}m (threshold: 50.0m)")
-
-        # 3. CHECK: Total length preserved (within 1%)
-        total_length_original = (
-            proc.con.execute(f"""
-            SELECT SUM(length_m) FROM {split_table}
-        """).fetchone()[0]
-            or 0
-        )
-
-        total_length_new = (
-            proc.con.execute(f"""
-            SELECT SUM(length_m) FROM {new_table}
-        """).fetchone()[0]
-            or 0
-        )
-
-        if total_length_original > 0:
-            length_diff = abs(total_length_new - total_length_original)
-            length_diff_pct = length_diff / total_length_original * 100
-
-            assert (
-                length_diff_pct < 1.0
-            ), f"Total length changed by {length_diff_pct:.2f}% (> 1% tolerance)"
-            logger.info(
-                f"✓ Total length preserved: {total_length_original:.1f}m → {total_length_new:.1f}m ({length_diff_pct:.2f}% diff)"
-            )
-
-        # 4. CHECK: All interpolated edges have proper naming
-        bad_names = proc.con.execute(f"""
-            SELECT COUNT(*)
-            FROM {new_table} 
-            WHERE edge_id LIKE '%_seg_%'
-              AND NOT REGEXP_MATCHES(edge_id, '_seg_[0-9]+$')
-        """).fetchone()[0]
-
-        assert bad_names == 0, f"Found {bad_names} edges with malformed segment names"
-        logger.info("✓ All segment names are properly formatted")
-
-        # 5. CHECK: Node connectivity - each interpolated node connects exactly 2 edges
-        node_connectivity = proc.con.execute(f"""
-            WITH interpolated_nodes AS (
-                SELECT DISTINCT source as node_id FROM {new_table} WHERE source LIKE 'interp_%'
-                UNION
-                SELECT DISTINCT target as node_id FROM {new_table} WHERE target LIKE 'interp_%'
-            ),
-            connections AS (
-                SELECT 
-                    n.node_id,
-                    COUNT(e.edge_id) as connection_count
-                FROM interpolated_nodes n
-                LEFT JOIN {new_table} e ON n.node_id = e.source OR n.node_id = e.target
-                GROUP BY n.node_id
-            )
-            SELECT 
-                COUNT(*) as total_interpolated_nodes,
-                COUNT(*) FILTER (WHERE connection_count != 2) as bad_nodes
-            FROM connections
-        """).fetchone()
-
-        assert (
-            node_connectivity[1] == 0
-        ), f"Found {node_connectivity[1]} interpolated nodes with != 2 connections"
-        logger.info(
-            f"✓ All {node_connectivity[0]} interpolated nodes have exactly 2 connections"
-        )
-
-        # 6. CHECK: Geometry validity
-        invalid_geoms = proc.con.execute(f"""
-            SELECT COUNT(*) 
-            FROM {new_table} 
-            WHERE ST_GeometryType({proc._meta.geometry_column}) != 'LINESTRING'
-               OR ST_IsEmpty({proc._meta.geometry_column})
-        """).fetchone()[0]
-
-        assert invalid_geoms == 0, f"Found {invalid_geoms} invalid geometries"
-        logger.info("✓ All geometries are valid LINESTRINGs")
-
-        # 7. CHECK: Segment ordering for each original edge
-        segment_ordering = proc.con.execute(f"""
-            WITH segments AS (
-                SELECT 
-                    edge_id,
-                    SPLIT_PART(edge_id, '_seg_', 1) as original_edge,
-                    TRY_CAST(SPLIT_PART(edge_id, '_seg_', 2) AS INTEGER) as segment_num
-                FROM {new_table}
-                WHERE edge_id LIKE '%_seg_%'
-                AND TRY_CAST(SPLIT_PART(edge_id, '_seg_', 2) AS INTEGER) IS NOT NULL
-            ),
-            ordering_issues AS (
-                SELECT 
-                    original_edge,
-                    COUNT(*) as total_segments,
-                    COUNT(DISTINCT segment_num) as unique_segments,
-                    MIN(segment_num) as min_segment,
-                    MAX(segment_num) as max_segment,
-                    LIST_SORT(LIST(segment_num)) as segment_list
-                FROM segments
-                GROUP BY original_edge
-                HAVING COUNT(DISTINCT segment_num) != COUNT(*)
-                   OR MIN(segment_num) != 1
-                   OR MAX(segment_num) != COUNT(*)
-            )
-            SELECT COUNT(*) as ordering_problems FROM ordering_issues
-        """).fetchone()[0]
-
-        assert (
-            segment_ordering == 0
-        ), f"Found {segment_ordering} edges with segment ordering issues"
-        logger.info("✓ All segments are properly numbered (1, 2, 3...)")
-
-        # 8. CHECK: No duplicate edge IDs
-        duplicate_edges = proc.con.execute(f"""
-            SELECT COUNT(*) - COUNT(DISTINCT edge_id) 
-            FROM {new_table}
-        """).fetchone()[0]
-
-        assert duplicate_edges == 0, f"Found {duplicate_edges} duplicate edge IDs"
-        logger.info("✓ No duplicate edge IDs")
-
-        # 9. CHECK: Cost proportional to length
-        cost_check = proc.con.execute(f"""
-            WITH interpolated_edges AS (
-                SELECT 
-                    edge_id,
-                    length_m,
-                    cost,
-                    cost / NULLIF(length_m, 0) as cost_per_meter
-                FROM {new_table}
-                WHERE edge_id LIKE '%_seg_%'
-                AND length_m > 0
-            ),
-            -- Group by original edge to check consistency within each split
-            edge_groups AS (
-                SELECT
-                    SPLIT_PART(edge_id, '_seg_', 1) as original_edge,
-                    AVG(cost_per_meter) as avg_cost_per_m,
-                    STDDEV_POP(cost_per_meter) as std_cost_per_m
-                FROM interpolated_edges
-                GROUP BY SPLIT_PART(edge_id, '_seg_', 1)
-            )
-            -- Check if any segment deviates significantly from its group average
-            SELECT COUNT(*)
-            FROM interpolated_edges ie
-            JOIN edge_groups eg ON SPLIT_PART(ie.edge_id, '_seg_', 1) = eg.original_edge
-            WHERE ABS(ie.cost_per_meter - eg.avg_cost_per_m) > 0.1 * eg.avg_cost_per_m  -- 10% tolerance
-        """).fetchone()[0]
-
-        assert (
-            cost_check == 0
-        ), f"Found {cost_check} segments with inconsistent cost/length ratios"
-        logger.info("✓ Cost distribution is consistent within each original edge")
-
-        # 10. CHECK: Network is connected
-        connectivity_check = proc.con.execute(f"""
-            WITH all_nodes AS (
-                SELECT source as node FROM {new_table}
-                UNION 
-                SELECT target as node FROM {new_table}
-            ),
-            node_degrees AS (
-                SELECT
-                    n.node,
-                    COUNT(e.edge_id) as degree
-                FROM all_nodes n
-                LEFT JOIN {new_table} e ON n.node = e.source OR n.node = e.target
-                GROUP BY n.node
-            )
-            SELECT COUNT(*) as isolated_nodes
-            FROM node_degrees
-            WHERE degree = 0
-        """).fetchone()[0]
-
-        assert connectivity_check == 0, f"Found {connectivity_check} isolated nodes"
-        logger.info("✓ No isolated nodes (all nodes have at least 1 connection)")
-
-        # 11. Segment endpoints should connect
-        disconnected_segments = proc.con.execute(f"""
-            WITH segments AS (
-                SELECT 
-                    edge_id,
-                    source,
-                    target,
-                    SPLIT_PART(edge_id, '_seg_', 1) as original_edge,
-                    TRY_CAST(SPLIT_PART(edge_id, '_seg_', 2) AS INTEGER) as seg_num,
-                    ST_StartPoint({proc._meta.geometry_column}) as start_geom,
-                    ST_EndPoint({proc._meta.geometry_column}) as end_geom
-                FROM {new_table}
-                WHERE edge_id LIKE '%_seg_%'
-            ),
-            connections AS (
-                SELECT
-                    s1.edge_id as edge1,
-                    s2.edge_id as edge2,
-                    ST_Distance(s1.end_geom, s2.start_geom) * 111320 as distance_m
-                FROM segments s1
-                JOIN segments s2 ON s1.original_edge = s2.original_edge 
-                    AND s1.seg_num + 1 = s2.seg_num
-                WHERE s1.seg_num IS NOT NULL AND s2.seg_num IS NOT NULL
-            )
-            SELECT COUNT(*) as disconnected_pairs
-            FROM connections
-            WHERE distance_m > 0.1  -- More than 10cm gap
-        """).fetchone()[0]
-
-        assert (
-            disconnected_segments == 0
-        ), f"Found {disconnected_segments} disconnected segment pairs"
-        logger.info("✓ All segment endpoints connect properly (< 10cm gaps)")
-
-        logger.info(
-            f"\n✅ SUCCESS: Interpolated network is valid!\n"
-            f"   Original: {split_stats['edge_count']} edges\n"
-            f"   After: {new_stats['edge_count']} edges\n"
-            f"   Max segment: {max_length:.1f}m\n"
-            f"   All checks passed ✓"
-        )
diff --git a/packages/python/goatlib/tests/integration/network/test_network_preprocessing.py b/packages/python/goatlib/tests/integration/network/test_network_preprocessing.py
deleted file mode 100644
index 2e87d230c..000000000
--- a/packages/python/goatlib/tests/integration/network/test_network_preprocessing.py
+++ /dev/null
@@ -1,368 +0,0 @@
-import logging
-from pathlib import Path
-
-import pytest
-from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
-from goatlib.routing.schemas.base import Coordinates
-
-logger = logging.getLogger(__name__)
-
-
-def test_buffered_subset_creation(network_file: Path):
-    """Test creating a spatial subset of network within a buffer."""
-    # Munich city center coordinates
-    center = Coordinates(lat=48.1351, lon=11.5820)
-    buffer_radius = 3000  # 3km
-
-    with InMemoryNetworkProcessor(str(network_file)) as processor:
-        # Create buffered subset using load_network (which creates subset)
-        subset_table = processor.load_network(
-            center=center, buffer_radius=buffer_radius
-        )
-
-        # Get statistics
-        subset_stats = processor.get_network_stats(subset_table)
-        original_stats = processor.get_network_stats(processor.network_table_name)
-
-        # Verify subset is smaller than original (for reasonable buffer sizes)
-        if buffer_radius < 50000:  # Only check for modest buffers
-            assert subset_stats["edge_count"] < original_stats["edge_count"]
-
-        assert subset_stats["edge_count"] > 0
-        logger.info(
-            f"Created subset with {subset_stats['edge_count']} edges (original: {original_stats['edge_count']})"
-        )
-
-
-def test_edge_splitting_at_point(network_file: Path):
-    """Test splitting closest edge at a given point."""
-    # Point near Munich center
-    point = Coordinates(lat=48.1370, lon=11.5760)
-
-    with InMemoryNetworkProcessor(str(network_file)) as processor:
-        # First load a buffered subset for faster testing
-        subset_table = processor.load_network(center=point, buffer_radius=2000)
-
-        # Split edge at the point
-        split_table, split_meta = processor.split_edge_at_point(
-            point=point,
-            source_table=subset_table,
-            max_search_radius_m=200,
-        )
-
-        # Verify split operation metadata
-        assert "split_operation" in split_meta.raw_meta
-        split_info = split_meta.raw_meta["split_operation"]
-        assert "artificial_node_id" in split_info
-        assert "original_edge" in split_info
-        assert 0.0 <= split_info["split_position"]["fraction"] <= 1.0
-
-        # Verify new node coordinates are close to input point
-        actual_point = split_info["split_position"]["actual_point"]
-        assert abs(actual_point["lat"] - point.lat) < 0.01  # Within ~1km
-        assert abs(actual_point["lon"] - point.lon) < 0.01
-
-        # Verify split table has more edges (original edge replaced with 2 parts)
-        subset_stats = processor.get_network_stats(subset_table)
-        split_stats = processor.get_network_stats(split_table)
-        assert split_stats["edge_count"] == subset_stats["edge_count"] + 1
-        logger.info(
-            f"Split edge: {subset_stats['edge_count']} → {split_stats['edge_count']} edges"
-        )
-
-
-def test_split_edge_at_point_with_subset(network_file: Path):
-    """Test the combined split with subset method."""
-    point = Coordinates(lat=48.137154, lon=11.576124)
-
-    with InMemoryNetworkProcessor(str(network_file)) as proc:
-        # This loads subset and splits in one call
-        split_table, split_meta = proc.split_edge_at_point_with_subset(
-            point=point,
-            network_buffer_radius=500.0,
-            max_search_radius_m=100.0,
-        )
-
-        # Verify results
-        assert "split_operation" in split_meta.raw_meta
-
-        stats = proc.get_network_stats(split_table)
-        assert stats["edge_count"] > 0
-        logger.info(f"Split with subset: {stats['edge_count']} edges")
-
-
-def test_complete_preprocessing_workflow(network_file: Path):
-    """Test the complete workflow: buffer → split → interpolate."""
-    # Origin point
-    origin = Coordinates(lat=48.1351, lon=11.5820)
-    buffer_radius = 5000  # 5km
-
-    with InMemoryNetworkProcessor(str(network_file)) as processor:
-        # Step 1: Create buffered subset
-        subset_table = processor.load_network(
-            center=origin, buffer_radius=buffer_radius
-        )
-
-        subset_stats = processor.get_network_stats(subset_table)
-        assert subset_stats["edge_count"] > 0
-        logger.info(f"📊 Subset contains {subset_stats['edge_count']} edges")
-
-        # Step 2: Split edge at origin point
-        split_table, split_meta = processor.split_edge_at_point(
-            point=origin,
-            source_table=subset_table,
-            max_search_radius_m=200,
-        )
-
-        origin_node_id = split_meta.raw_meta["split_operation"]["artificial_node_id"]
-        assert origin_node_id is not None
-        assert origin_node_id.startswith("split_node_") or origin_node_id.startswith(
-            "n_"
-        )
-        logger.info(f"🎯 Origin node created: {origin_node_id}")
-
-        split_stats = processor.get_network_stats(split_table)
-        logger.info(f"📈 Split network has {split_stats['edge_count']} edges")
-
-        # Verify edges are connected to the artificial node
-        connected_edges = processor.con.execute(
-            f"""
-            SELECT COUNT(*)
-            FROM {split_table}
-            WHERE source = '{origin_node_id}' OR target = '{origin_node_id}'
-            """
-        ).fetchone()[0]
-        assert connected_edges == 2  # Should connect exactly 2 edges (the split parts)
-        logger.info(f"🔗 {connected_edges} edges connected to origin node")
-
-        # Step 3: Interpolate long edges
-        interpolated_table, interp_meta = processor.interpolate_long_edges(
-            max_edge_length=50.0,
-            base_table=split_table,
-            include_stats=True,
-        )
-
-        interp_stats = processor.get_network_stats(interpolated_table)
-        logger.info(f"✂️  Interpolated to {interp_stats['edge_count']} edges")
-
-        # Verify workflow produced valid network
-        assert interp_stats["edge_count"] > split_stats["edge_count"]
-
-
-def test_edge_interpolation(network_file: Path):
-    """Test interpolation of long edges into smaller segments."""
-    max_edge_length = 100.0  # Split edges longer than 100m
-
-    with InMemoryNetworkProcessor(str(network_file)) as processor:
-        # Load a subset first for faster testing
-        center = Coordinates(lat=48.1351, lon=11.5820)
-        subset_table = processor.load_network(center=center, buffer_radius=2000)
-
-        # Get original stats
-        original_stats = processor.get_network_stats(subset_table)
-        logger.info(f"\n📊 Original network: {original_stats['edge_count']} edges")
-        logger.info(f"   Max edge length: {original_stats['max_length_m']:.2f}m")
-
-        # Count long edges
-        long_edges = processor.con.execute(
-            f"""
-            SELECT COUNT(*)
-            FROM {subset_table}
-            WHERE length_m > {max_edge_length}
-            """
-        ).fetchone()[0]
-        logger.info(f"   Long edges (>{max_edge_length}m): {long_edges}")
-
-        # Interpolate long edges
-        interpolated_table, interp_meta = processor.interpolate_long_edges(
-            max_edge_length=max_edge_length,
-            base_table=subset_table,
-            include_stats=True,
-        )
-
-        # Verify interpolation metadata
-        if "stats" in interp_meta.raw_meta:
-            stats = interp_meta.raw_meta["stats"]
-            logger.info(f"✂️  Segments created: {stats.get('segments_added', 'N/A')}")
-            logger.info(
-                f"   Max segment: {stats.get('max_segment_length', 'N/A'):.1f}m"
-            )
-        elif "interpolation_operation" in interp_meta.raw_meta:
-            interp_info = interp_meta.raw_meta["interpolation_operation"]
-            logger.info(
-                f"✂️  Interpolated network: {interp_info.get('final_edge_count', 'N/A')} edges"
-            )
-            logger.info(f"   Edges added: {interp_info.get('edges_added', 'N/A')}")
-
-        # Verify no edge exceeds max length (with tolerance)
-        longest_edge = (
-            processor.con.execute(
-                f"""
-            SELECT MAX(length_m)
-            FROM {interpolated_table}
-            WHERE edge_id LIKE '%_s%' OR edge_id LIKE '%_seg_%'
-            """
-            ).fetchone()[0]
-            or 0
-        )
-        assert longest_edge <= max_edge_length * 1.1  # Allow 10% tolerance
-        logger.info(f"   New max segment length: {longest_edge:.2f}m ✅")
-
-
-def test_interpolate_point_on_edge(network_file: Path):
-    """Test interpolating a point along an edge."""
-    with InMemoryNetworkProcessor(str(network_file)) as proc:
-        # First split at a point
-        split_table, split_meta = proc.split_edge_at_point_with_subset(
-            point=Coordinates(lat=48.137154, lon=11.576124),
-            network_buffer_radius=500.0,
-            max_search_radius_m=100.0,
-        )
-
-        split_stats = proc.get_network_stats(split_table)
-        logger.info(f"Split network: {split_stats['edge_count']} edges")
-
-        # Then interpolate long edges
-        new_table, new_meta = proc.interpolate_long_edges(
-            base_table=split_table,
-            max_edge_length=50.0,
-        )
-
-        new_stats = proc.get_network_stats(new_table)
-        logger.info(f"Interpolated network: {new_stats['edge_count']} edges")
-
-        # Basic checks
-        assert new_stats["edge_count"] >= split_stats["edge_count"]
-        assert split_meta.raw_meta.get("split_operation", {}) is not None
-
-        # Check metadata exists (structure depends on include_stats)
-        assert new_meta.raw_meta is not None
-
-
-@pytest.mark.parametrize(
-    "lat,lon,buffer_radius",
-    [
-        (48.1351, 11.5820, 1000),  # Small buffer
-        (48.1351, 11.5820, 5000),  # Medium buffer
-        (48.1351, 11.5820, 10000),  # Large buffer
-    ],
-)
-def test_buffer_radius_variations(
-    network_file: Path, lat: float, lon: float, buffer_radius: float
-):
-    """Test that larger buffers result in more edges."""
-    center = Coordinates(lat=lat, lon=lon)
-
-    with InMemoryNetworkProcessor(str(network_file)) as processor:
-        subset_table = processor.load_network(
-            center=center, buffer_radius=buffer_radius
-        )
-
-        stats = processor.get_network_stats(subset_table)
-        logger.info(f"\n📏 Buffer {buffer_radius}m: {stats['edge_count']} edges")
-
-        # Verify proportional relationship exists (larger buffer = more edges)
-        assert stats["edge_count"] > 0
-
-
-def test_error_handling_point_too_far_from_network(network_file: Path):
-    """Test error handling when point is too far from any edge."""
-    # Point in the middle of nowhere (Atlantic Ocean)
-    point = Coordinates(lat=0.0, lon=0.0)
-
-    with InMemoryNetworkProcessor(str(network_file)) as proc:
-        # load_network should work (creates empty or small subset)
-        subset_table = proc.load_network(center=point, buffer_radius=1000)
-
-        # But split_edge_at_point should fail
-        with pytest.raises(ValueError, match="No edge found within"):
-            proc.split_edge_at_point(
-                point=point,
-                source_table=subset_table,
-                max_search_radius_m=1000.0,  # Even large radius
-            )
-
-
-def test_error_handling_invalid_split_position(network_file: Path):
-    """Test error handling when split point is at edge endpoint."""
-    with InMemoryNetworkProcessor(str(network_file)) as proc:
-        # Load a subset
-        center = Coordinates(lat=48.1351, lon=11.5820)
-        subset_table = proc.load_network(center=center, buffer_radius=1000)
-
-        # Find an actual edge endpoint to test
-        result = proc.con.execute(f"""
-            SELECT 
-                source,
-                ST_X(ST_StartPoint({proc._meta.geometry_column})) as start_lon,
-                ST_Y(ST_StartPoint({proc._meta.geometry_column})) as start_lat
-            FROM {subset_table}
-            LIMIT 1
-        """).fetchone()
-
-        if result:
-            # Try to split at the exact start of an edge
-            point = Coordinates(lat=result[2], lon=result[1])
-
-            # This might fail or warn depending on implementation
-            try:
-                split_table, meta = proc.split_edge_at_point(
-                    point=point,
-                    source_table=subset_table,
-                    max_search_radius_m=10.0,
-                )
-                # If it succeeds, check warning in metadata
-                logger.info("Split at endpoint succeeded (fraction should be ~0)")
-            except ValueError as e:
-                if "too close to endpoint" in str(e):
-                    logger.info(f"Correctly rejected split at endpoint: {e}")
-                else:
-                    raise
-
-
-def test_network_stats_method(network_file: Path):
-    """Test the get_network_stats method."""
-    with InMemoryNetworkProcessor(str(network_file)) as proc:
-        # Test on main network
-        proc.load_network()
-        stats = proc.get_network_stats()
-        assert "edge_count" in stats
-        assert "total_length_m" in stats
-        assert "avg_length_m" in stats
-        assert stats["edge_count"] > 0
-
-        logger.info(
-            f"Main network: {stats['edge_count']} edges, {stats['total_length_m']:.0f}m total"
-        )
-
-        # Test on subset
-        subset = proc.load_network(
-            center=Coordinates(lat=48.1351, lon=11.5820), buffer_radius=1000
-        )
-        subset_stats = proc.get_network_stats(subset)
-        assert subset_stats["edge_count"] > 0
-        assert subset_stats["edge_count"] <= stats["edge_count"]
-
-
-def test_apply_sql_query(network_file: Path):
-    """Test applying custom SQL queries."""
-    with InMemoryNetworkProcessor(str(network_file)) as proc:
-        table = proc.load_network(
-            center=Coordinates(lat=48.1351, lon=11.5820), buffer_radius=2000
-        )
-        # Create a simple filtered table
-        result_table = proc.apply_sql_query(
-            sql_query=f"""
-            SELECT * 
-            FROM {table} 
-            WHERE length_m > 100 
-            LIMIT 10
-            """,
-            result_table="long_edges",
-        )
-
-        stats = proc.get_network_stats(result_table)
-        assert stats["edge_count"] <= 10
-        assert stats["min_length_m"] > 100
-
-        logger.info(f"SQL query created table with {stats['edge_count']} edges > 100m")
diff --git a/packages/python/goatlib/tests/integration/routing/network/test_catchment.py b/packages/python/goatlib/tests/integration/routing/network/test_catchment.py
new file mode 100644
index 000000000..1b11647e6
--- /dev/null
+++ b/packages/python/goatlib/tests/integration/routing/network/test_catchment.py
@@ -0,0 +1,225 @@
+import logging
+import os
+import time
+from pathlib import Path
+
+import fast_routing_py as routing
+from goatlib.analysis.network.network_processor import (
+    InMemoryNetworkProcessor,
+)
+from goatlib.routing.schemas.base import Coordinates
+
+logger = logging.getLogger(__name__)
+
+example_request = {
+    "starting_points": [{"lat": 48.1351, "lon": 11.5820}],  # Munich central
+    "cutoffs": [10, 20, 30],
+    "type": "point",
+}
+
+
+def test_catchment_workflow(network_file: Path):
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        # Use the new optimized method that combines all preprocessing
+        start_coords = Coordinates(lat=48.1351, lon=11.5820)
+        parquet_path, start_node_id = proc.prepare_routing_network(
+            start_point=start_coords,
+            buffer_radius=1000.0,
+            travel_time_minutes=15.0,
+            speed_kmh=5.0,
+        )
+
+        # Load network with fast_routing_py and calculate isochrone
+        network = routing.load_network(parquet_path)
+
+        # Calculate isochrones for the requested cutoffs (convert minutes to seconds)
+        cutoffs_seconds = [c * 60 for c in [10, 20, 30]]
+        results = network.calculate_isochrone_multiple_times(
+            start_node=start_node_id, time_thresholds=cutoffs_seconds
+        )
+
+        assert len(results) == 3  # One result per cutoff
+        for i, result in enumerate(results):
+            assert result.reachable_nodes > 0
+            logger.info(
+                f"Cutoff {[10, 20, 30][i]} min: {result.reachable_nodes} reachable nodes"
+            )
+
+
+def test_optimized_catchment_benchmark(network_file: Path):
+    """
+    Benchmark the optimized catchment workflow with split-edge approach.
+    Tests realistic scenarios with performance targets.
+    """
+    logger.info("=== OPTIMIZED CATCHMENT BENCHMARK ===")
+
+    # Test configurations: [buffer_radius, travel_time, speed, expected_time_ms]
+    test_configs = [
+        (200, 2.0, 12.0, 85),  # Ultra-minimal for speed
+        (400, 3.0, 12.0, 95),  # Small catchment
+        (800, 5.0, 12.0, 110),  # Medium catchment
+    ]
+
+    results = []
+
+    for buffer_radius, travel_time, speed, expected_max_ms in test_configs:
+        logger.info(
+            f"\n--- Testing {buffer_radius}m buffer, {travel_time}min travel time ---"
+        )
+
+        # Run 3 iterations for stable timing
+        times = []
+        for run in range(3):
+            with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+                start_coords = Coordinates(lat=48.1351, lon=11.5820)
+
+                # Time the full preparation
+                t1 = time.time()
+                parquet_path, start_node_id = proc.prepare_routing_network(
+                    start_point=start_coords,
+                    buffer_radius=buffer_radius,
+                    travel_time_minutes=travel_time,
+                    speed_kmh=speed,
+                )
+                t2 = time.time()
+                prep_time = (t2 - t1) * 1000
+
+                # Quick routing test
+                t3 = time.time()
+                network = routing.load_network(parquet_path)
+                cutoffs_seconds = [5 * 60, 10 * 60]  # 5min, 10min
+                isochrones = network.calculate_isochrone_multiple_times(
+                    start_node=start_node_id, time_thresholds=cutoffs_seconds
+                )
+                t4 = time.time()
+                routing_time = (t4 - t3) * 1000
+
+                total_time = prep_time + routing_time
+                times.append(
+                    {
+                        "prep": prep_time,
+                        "routing": routing_time,
+                        "total": total_time,
+                        "nodes": sum(r.reachable_nodes for r in isochrones),
+                    }
+                )
+
+                # Cleanup
+                if os.path.exists(parquet_path):
+                    os.unlink(parquet_path)
+
+        # Calculate averages
+        avg_prep = sum(t["prep"] for t in times) / len(times)
+        avg_routing = sum(t["routing"] for t in times) / len(times)
+        avg_total = sum(t["total"] for t in times) / len(times)
+        avg_nodes = sum(t["nodes"] for t in times) / len(times)
+
+        # Log results
+        prep_status = "✓" if avg_prep < expected_max_ms else "✗"
+        total_status = "✓" if avg_total < expected_max_ms + 50 else "✗"
+
+        logger.info(f"  Network prep: {avg_prep:.1f}ms {prep_status}")
+        logger.info(f"  Routing calc: {avg_routing:.1f}ms")
+        logger.info(f"  Total time:   {avg_total:.1f}ms {total_status}")
+        logger.info(f"  Avg nodes:    {avg_nodes:.0f}")
+
+        results.append(
+            {
+                "config": f"{buffer_radius}m_{travel_time}min",
+                "prep_time": avg_prep,
+                "routing_time": avg_routing,
+                "total_time": avg_total,
+                "target_prep": expected_max_ms,
+                "nodes": avg_nodes,
+            }
+        )
+
+    # Summary analysis
+    logger.info("\n=== BENCHMARK SUMMARY ===")
+    best_prep = min(r["prep_time"] for r in results)
+    best_total = min(r["total_time"] for r in results)
+
+    logger.info(f"Best prep time: {best_prep:.1f}ms")
+    logger.info(f"Best total time: {best_total:.1f}ms")
+
+    # Performance assertions
+    assert best_prep < 100, f"Best prep time {best_prep:.1f}ms should be under 100ms"
+    assert best_total < 150, f"Best total time {best_total:.1f}ms should be under 150ms"
+    assert all(
+        r["nodes"] > 100 for r in results
+    ), "All configs should find substantial nodes"
+
+    logger.info("✓ Optimized catchment benchmark PASSED")
+
+
+def test_split_edge_accuracy_benchmark(network_file: Path):
+    """
+    Test the accuracy improvements of the optimized routing network preparation.
+    """
+    logger.info("=== OPTIMIZED ROUTING NETWORK ACCURACY BENCHMARK ===")
+
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        start_coords = Coordinates(lat=48.1351, lon=11.5820)
+
+        # Test optimized routing network preparation
+        t1 = time.time()
+        parquet_path, start_node_id = proc.prepare_routing_network(
+            start_point=start_coords, buffer_radius=500.0
+        )
+        t2 = time.time()
+
+        prep_time = (t2 - t1) * 1000
+
+        logger.info(f"Optimized routing prep: {prep_time:.1f}ms")
+        logger.info(f"  Start node ID: {start_node_id}")
+        logger.info(f"  Output file: {parquet_path}")
+
+        # Load the result to verify network quality
+        import duckdb
+
+        con = duckdb.connect(":memory:")
+        con.execute("INSTALL spatial; LOAD spatial;")
+
+        # Get network statistics
+        network_info = con.execute(f"""
+            SELECT 
+                COUNT(*) as edge_count,
+                COUNT(DISTINCT source) as unique_sources,
+                COUNT(DISTINCT target) as unique_targets,
+                AVG(length_m) as avg_length
+            FROM read_parquet('{parquet_path}')
+        """).fetchone()
+
+        edge_count = network_info[0]
+        unique_nodes = len(
+            set([network_info[1], network_info[2]])
+        )  # Approximate unique nodes
+        avg_length = network_info[3]
+
+        logger.info(f"  Network edges: {edge_count}")
+        logger.info(f"  Avg edge length: {avg_length:.1f}m")
+
+        # Verify the start node exists in the network
+        start_node_exists = con.execute(f"""
+            SELECT COUNT(*) FROM read_parquet('{parquet_path}')
+            WHERE source = {start_node_id} OR target = {start_node_id}
+        """).fetchone()[0]
+
+        logger.info(f"  Start node connectivity: {start_node_exists} edges")
+
+        # Clean up
+        import os
+
+        if os.path.exists(parquet_path):
+            os.unlink(parquet_path)
+        con.close()
+
+        # Assertions for quality
+        assert edge_count > 100, "Network should have substantial edges"
+        assert start_node_exists > 0, "Start node should be connected to the network"
+        assert avg_length > 0, "Edges should have positive length"
+        assert (
+            prep_time < 150
+        ), f"Preparation took {prep_time:.1f}ms, should be under 150ms"
+
+        logger.info("✓ Optimized routing network accuracy benchmark PASSED")
diff --git a/packages/python/goatlib/tests/unit/analysis/test_network.py b/packages/python/goatlib/tests/unit/analysis/test_network.py
index d49081c05..a593b64c8 100644
--- a/packages/python/goatlib/tests/unit/analysis/test_network.py
+++ b/packages/python/goatlib/tests/unit/analysis/test_network.py
@@ -1,7 +1,6 @@
 import logging
 from pathlib import Path
 
-import pytest
 from goatlib.analysis.network.network_processor import (
     InMemoryNetworkProcessor,
 )
@@ -10,247 +9,254 @@
 logger = logging.getLogger(__name__)
 
 
-@pytest.fixture
-def processor(network_file: Path) -> InMemoryNetworkProcessor:
-    """A pytest fixture that yields a processor within a context manager."""
+def test_network_loading(network_file: Path) -> None:
+    """Test basic network loading without specific coordinates."""
     with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
-        proc.load_network()
-        yield proc
-    # Cleanup is handled automatically as the 'with' block exits
-
-
-# ------------ Test Cases ------------
-
+        # Test metadata loading
+        metadata = proc.metadata
+        assert metadata is not None
+        assert metadata.geometry_column == "geometry"
+        assert len(metadata.columns) > 0
 
-def test_network_loading(
-    processor: InMemoryNetworkProcessor,
-) -> None:
-    """Tests chaining non-destructive operations and verifies intermediate results."""
-    with InMemoryNetworkProcessor(input_path=processor._db_path) as proc:
         table_name = proc.load_network()
+        assert table_name is not None
 
-        metadata = processor.network_metadata
-        assert metadata is not None
+        # Verify table exists and has data
+        count = proc.con.execute(f"SELECT COUNT(*) FROM {table_name}").fetchone()[0]
+        assert count > 0, "Network should have loaded some data"
 
-        stats = processor.get_network_stats()
-        assert stats["edge_count"] > 0
-        assert stats["total_length_m"] > 0.0
-        logger.info(
-            f"Network table '{table_name}' has {stats['edge_count']} edges, total length {stats['total_length_m']:.1f}m"
-        )
+        logger.info(f"Network table '{table_name}' loaded with {count} sample edges")
 
 
-def test_network_loading_with_point(
-    processor: InMemoryNetworkProcessor,
-) -> None:
-    """Tests chaining non-destructive operations and verifies intermediate results."""
-    with InMemoryNetworkProcessor(input_path=processor._db_path) as proc:
+def test_network_loading_with_point(network_file: Path) -> None:
+    """Test network loading with spatial filtering around a specific point."""
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        # Load network subset around a specific point
         table_name = proc.load_network(
             center=Coordinates(lat=48.137154, lon=11.576124),
             buffer_radius=1000.0,
-            travel_time_minutes=15.0,
-            speed_kmh=5.0,
         )
-    cut_stats = processor.get_network_stats(table_name)
-    assert cut_stats["edge_count"] > 0
-    assert cut_stats["total_length_m"] > 0.0
-    logger.info(
-        f"Cut network table '{table_name}' has {cut_stats['edge_count']} edges, total length {cut_stats['total_length_m']:.1f}m"
-    )
-
-    output_path = "/app/packages/python/goatlib/tests/data/network/test.parquet"
-    # save table name for confirmation
-    processor.save_network(table_name, output_path)
 
+        # Verify the filtered network
+        count = proc.con.execute(f"SELECT COUNT(*) FROM {table_name}").fetchone()[0]
+        assert count > 0, "Filtered network should have edges"
 
-def test_save_to_file(processor: InMemoryNetworkProcessor, data_root: Path) -> None:
-    """Test saving a table to a parquet file."""
-    output_file = data_root / "network" / "network_output.parquet"
-    processor.save_network(processor.network_table_name, output_path=str(output_file))
+        # Verify spatial filtering worked
+        sample = proc.con.execute(
+            f"SELECT edge_id, source, target, length_m FROM {table_name} LIMIT 1"
+        ).fetchone()
+        assert sample is not None, "Should have at least one edge"
+        assert sample[3] > 0, "Edge should have positive length"
 
-    # Verify the file was created
-    assert output_file.exists()
-    assert output_file.stat().st_size > 0
+        logger.info(f"Filtered network table '{table_name}' has {count} edges")
 
 
-def test_save_to_tmp(processor: InMemoryNetworkProcessor) -> None:
-    """Test saving a table to a temporary parquet file."""
-    tmp_file_path = processor.save_network(processor.network_table_name)
-    # Verify the file was created
-    from pathlib import Path
+def test_prepare_routing_network(network_file: Path) -> None:
+    """Test the core routing network preparation functionality."""
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        start_point = Coordinates(lat=48.137154, lon=11.576124)
 
-    tmp_file = Path(tmp_file_path)
-    assert tmp_file.exists()
-    assert tmp_file.stat().st_size > 0
-    logger.info(f"Temporary network file created at: {tmp_file_path}")
+        # Test routing network preparation
+        output_path, new_node_id = proc.prepare_routing_network(
+            start_point=start_point, buffer_radius=500.0
+        )
 
+        # Verify outputs
+        assert output_path.endswith(".parquet"), "Should return parquet file path"
+        assert isinstance(new_node_id, int), "Should return integer node ID"
+        assert new_node_id > 0, "Node ID should be positive"
 
-def test_network_is_wkb_format(processor: InMemoryNetworkProcessor) -> None:
-    """Test that the network geometries are in WKB format."""
-    sample_geometry = processor.con.execute(
-        f"SELECT geometry FROM {processor.network_table_name} LIMIT 1"
-    ).fetchone()[0]
+        # Verify the output file was created
+        import os
 
-    assert isinstance(
-        sample_geometry, bytes
-    ), f"Geometry should be in WKB format (bytes), got {type(sample_geometry)}"
+        assert os.path.exists(output_path), "Output file should exist"
 
+        # Clean up
+        os.unlink(output_path)
 
-def test_get_available_tables(
-    processor: InMemoryNetworkProcessor,
-) -> None:
-    """Test listing available tables in the in-memory database."""
-    tables = processor.get_available_tables()
-    assert isinstance(tables, list)
-    assert processor.network_table_name in tables
-    logger.info(f"Network table: {processor.network_table_name}")
-    logger.info(f"Available tables: {tables}")
+        logger.info(f"Successfully prepared routing network with node {new_node_id}")
 
 
-def test_split_with_subset_basic(network_file: Path) -> None:
-    """Basic test that splitting works."""
+def test_network_geometry_format(network_file: Path) -> None:
+    """Test that network geometries are properly handled."""
     with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
-        # Try to split
-        split_table, split_meta = proc.split_edge_at_point_with_subset(
-            point=Coordinates(lat=48.137154, lon=11.576124),
-            network_buffer_radius=500.0,
-            max_search_radius_m=100.0,
+        # Load small network subset
+        table_name = proc.load_network(
+            center=Coordinates(lat=48.137154, lon=11.576124), buffer_radius=200.0
         )
 
-        # Basic assertions
-        assert split_table in proc.get_available_tables()
+        # Check geometry column exists and has data
+        geometry_sample = proc.con.execute(
+            f"SELECT geometry FROM {table_name} LIMIT 1"
+        ).fetchone()[0]
 
-        stats = proc.get_network_stats(split_table)
-        assert 0 < stats["edge_count"] < 375164
+        assert geometry_sample is not None, "Geometry should not be null"
+        assert isinstance(geometry_sample, bytes), "Geometry should be in binary format"
 
-        split_info = split_meta.raw_meta.get("split_operation", {})
-        assert split_info.get("original_edge")
-        assert split_info.get("artificial_node_id")
+        # Test conversion to text format
+        wkt_sample = proc.con.execute(
+            f"SELECT ST_AsText(geometry) FROM {table_name} LIMIT 1"
+        ).fetchone()[0]
 
-        # Quick validation of split
-        fraction = split_info["split_position"]["fraction"]
-        assert 0.0 <= fraction <= 1.0
+        assert wkt_sample is not None, "WKT conversion should work"
+        assert isinstance(wkt_sample, str), "WKT should be string"
+        assert "LINESTRING" in wkt_sample.upper(), "Should be LineString geometry"
 
-        logger.info(f"Basic test passed: split {split_info['original_edge']}")
+        logger.info(f"Geometry format verified: {wkt_sample[:50]}...")
 
 
-def test_split_with_subset_advanced(network_file: Path) -> None:
-    """Test splitting edge on a network subset without loading full network."""
+def test_interpolate_long_edges(network_file: Path) -> None:
+    """Test edge interpolation functionality."""
     with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
-        # This loads only ~500m radius around the point, not the full 375k edges
-        split_table, split_meta = proc.split_edge_at_point_with_subset(
-            point=Coordinates(lat=48.137154, lon=11.576124),
-            network_buffer_radius=500.0,
-            max_search_radius_m=100.0,
+        # Load network subset
+        subset_table = proc.load_network(
+            center=Coordinates(lat=48.137154, lon=11.576124), buffer_radius=500.0
         )
 
-        # Get available tables
-        tables = proc.get_available_tables()
-        logger.info(f"Available tables after split: {tables}")
+        # Get edge count before interpolation
+        count_before = proc.con.execute(
+            f"SELECT COUNT(*) FROM {subset_table}"
+        ).fetchone()[0]
 
-        # Check that split table exists
-        assert split_table in tables, f"Split table {split_table} not found in {tables}"
+        # Interpolate long edges
+        interp_table, interp_meta = proc.interpolate_long_edges(
+            max_edge_length=100.0, base_table=subset_table
+        )
 
-        # Get stats for split table
-        stats = proc.get_network_stats(split_table)
-        logger.info(f"Split table stats: {stats}")
+        # Get edge count after interpolation
+        count_after = proc.con.execute(
+            f"SELECT COUNT(*) FROM {interp_table}"
+        ).fetchone()[0]
 
-        # Verify the subset is smaller than full network
+        # Verify interpolation worked
         assert (
-            stats["edge_count"] < 375164
-        ), "Subset should be smaller than full network"
-        assert stats["edge_count"] > 0, "Subset should have at least one edge"
-
-        # Verify the split worked
-        split_info = split_meta.raw_meta.get("split_operation", {})  # Fixed key name
-        assert split_info.get("original_edge") is not None, "Missing original edge ID"
-        assert split_info.get("artificial_node_id") is not None, "Missing new node ID"
-        assert (
-            split_info.get("split_position", {}).get("fraction") is not None
-        ), "Missing split fraction"
+            count_after >= count_before
+        ), "Should have same or more edges after interpolation"
+        assert interp_meta is not None, "Should return metadata"
+        assert interp_meta.geometry_column == "geometry"
 
-        # Verify split fraction is reasonable
-        fraction = split_info["split_position"]["fraction"]
-        assert (
-            0.001 <= fraction <= 0.999
-        ), f"Split fraction {fraction} should be between 0.001 and 0.999"
+        logger.info(f"Interpolated {count_before} -> {count_after} edges")
 
-        # Verify distance is within search radius
-        distance_m = split_info["split_position"]["distance_m"]
-        assert (
-            distance_m <= 100.0
-        ), f"Distance {distance_m}m should be <= search radius 100m"
-
-        # Additional useful checks:
-
-        # 1. Check that split edge appears twice (parts A and B)
-        result = proc.con.execute(f"""
-            SELECT COUNT(*) 
-            FROM {split_table} 
-            WHERE edge_id LIKE '%_A' OR edge_id LIKE '%_B'
-        """).fetchone()
-        split_edge_count = result[0]
-        assert (
-            split_edge_count == 2
-        ), f"Should have 2 split edges, got {split_edge_count}"
-
-        # 2. Check new node connectivity
-        node_id = split_info["artificial_node_id"]
-        result = proc.con.execute(f"""
-            SELECT 
-                COUNT(*) as connections,
-                SUM(CASE WHEN source = '{node_id}' THEN 1 ELSE 0 END) as as_source,
-                SUM(CASE WHEN target = '{node_id}' THEN 1 ELSE 0 END) as as_target
-            FROM {split_table}
-            WHERE source = '{node_id}' OR target = '{node_id}'
-        """).fetchone()
-
-        assert result[0] == 2, f"New node should connect 2 edges, connects {result[0]}"
-        assert (
-            result[1] == 1
-        ), f"New node should be source for 1 edge, is source for {result[1]}"
-        assert (
-            result[2] == 1
-        ), f"New node should be target for 1 edge, is target for {result[2]}"
 
-        # 3. Check edge lengths sum correctly
-        original_length = split_info["edge_properties"]["original_length_m"]
-        part_a_length = split_info["edge_properties"]["part_a_length_m"]
-        part_b_length = split_info["edge_properties"]["part_b_length_m"]
+def test_split_architecture_performance(network_file: Path) -> None:
+    """Test the split architecture for loading vs processing performance."""
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        start_point = Coordinates(lat=48.137154, lon=11.576124)
+
+        # Test 1: Load network first
+        import time
+
+        t1 = time.perf_counter()
+        subset_table = proc.load_network(center=start_point, buffer_radius=400.0)
+        t2 = time.perf_counter()
+        load_time = (t2 - t1) * 1000
+
+        # Test 2: Reuse loaded data for routing preparation
+        t3 = time.perf_counter()
+        output_path, node_id = proc.prepare_routing_network(
+            start_point=start_point,
+            buffer_radius=400.0,
+            subset_table=subset_table,  # Reuse loaded data
+        )
+        t4 = time.perf_counter()
+        prep_time = (t4 - t3) * 1000
+
+        # Verify performance split
+        assert load_time > 0, "Load time should be measurable"
+        assert prep_time > 0, "Prep time should be measurable"
+        assert prep_time < load_time, "Routing prep should be faster than loading"
 
-        # Allow small floating point tolerance
-        total_split_length = part_a_length + part_b_length
-        length_diff = abs(original_length - total_split_length)
-        assert (
-            length_diff < 0.01
-        ), f"Split lengths don't sum to original: {original_length} != {total_split_length}"
+        # Clean up
+        import os
+
+        if os.path.exists(output_path):
+            os.unlink(output_path)
 
         logger.info(
-            f"✅ Test passed: Split {split_info['original_edge']} at {fraction:.3%}"
+            f"Split architecture: Load={load_time:.1f}ms, Prep={prep_time:.1f}ms"
         )
-        logger.info(f"   New node: {node_id}, Distance: {distance_m:.1f}m")
-        logger.info(f"   Part A: {part_a_length:.1f}m, Part B: {part_b_length:.1f}m")
 
 
-def test_interpolate_point_on_edge(network_file: Path) -> None:
-    """Test interpolating a point along an edge."""
+def test_cleanup_functionality(network_file: Path) -> None:
+    """Test that cleanup properly closes connections and removes temporary files."""
+    import os
+    from pathlib import Path
+
+    # Create processor and track its temporary directory
+    proc = InMemoryNetworkProcessor(input_path=str(network_file))
+    temp_dir_path = Path(proc._temp_dir)
+
+    # Verify temp directory exists
+    assert temp_dir_path.exists(), "Temporary directory should be created"
+
+    # Use the processor to create some files
+    proc.load_network(
+        center=Coordinates(lat=48.137154, lon=11.576124), buffer_radius=400.0
+    )
+
+    output_path, _ = proc.prepare_routing_network(
+        start_point=Coordinates(lat=48.137154, lon=11.576124), buffer_radius=400.0
+    )
+
+    # Verify the output file was created in temp directory
+    assert os.path.exists(output_path), "Output file should be created"
+    assert str(output_path).startswith(
+        str(temp_dir_path)
+    ), "Output should be in temp directory"
+
+    # Check connection is active
+    assert proc.con is not None, "Connection should be active"
+
+    # Test connection works
+    result = proc.con.execute("SELECT 1").fetchone()
+    assert result[0] == 1, "Connection should be functional"
+
+    # Call cleanup
+    proc.cleanup()
+
+    # Verify temp directory is removed
+    assert (
+        not temp_dir_path.exists()
+    ), "Temporary directory should be removed after cleanup"
+
+    # Verify output file is gone (part of temp directory)
+    assert not os.path.exists(
+        output_path
+    ), "Output file should be removed with temp directory"
+
+    logger.info(
+        "Cleanup test: Successfully removed temp directory and closed connection"
+    )
+
+
+def test_context_manager_cleanup(network_file: Path) -> None:
+    """Test that context manager automatically calls cleanup."""
+    import os
+
+    temp_dir_path = None
+    output_path = None
+
+    # Use context manager
     with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
-        # Try to split
-        split_table, split_meta = proc.split_edge_at_point_with_subset(
-            point=Coordinates(lat=48.137154, lon=11.576124),
-            network_buffer_radius=500.0,
-            max_search_radius_m=100.0,
-        )
-        stats = proc.get_network_stats(split_table)
-        new_table, new_meta = proc.interpolate_long_edges(
-            base_table=split_table,
-            max_edge_length=50.0,
-        )
-        new_stats = proc.get_network_stats(new_table)
+        temp_dir_path = Path(proc._temp_dir)
 
-        assert new_stats["edge_count"] >= stats["edge_count"]
-        logger.info(
-            f"Interpolated long edges: {stats['edge_count']} → {new_stats['edge_count']} edges"
+        # Verify temp directory exists during usage
+        assert temp_dir_path.exists(), "Temporary directory should exist during usage"
+
+        # Create some files
+        output_path, _ = proc.prepare_routing_network(
+            start_point=Coordinates(lat=48.137154, lon=11.576124), buffer_radius=400.0
         )
-        assert split_meta.raw_meta.get("split_operation", {}) is not None
-        assert new_meta.raw_meta.get("interpolation_operation", {}) is not None
+
+        # Verify file exists during usage
+        assert os.path.exists(output_path), "Output file should exist during usage"
+
+    # After context manager exits, verify cleanup happened automatically
+    assert (
+        not temp_dir_path.exists()
+    ), "Temporary directory should be cleaned up automatically"
+    assert not os.path.exists(
+        output_path
+    ), "Output file should be cleaned up automatically"
+
+    logger.info("Context manager test: Automatic cleanup successful")

From edd32ba002b3fc067080bf1649ca32e7f7f17c4d Mon Sep 17 00:00:00 2001
From: 96hoshi <marta.locascio@plan4better.de>
Date: Thu, 18 Dec 2025 16:28:54 +0000
Subject: [PATCH 08/11] wip: refactoring, removing fixtures, ultimating
 get_isochrone res/req, updated tests

---
 .../analysis/network/network_processor.py     | 411 ++++++++++++++++--
 .../routing/adapters/motis/motis_adapter.py   |  49 ++-
 .../routing/adapters/motis/motis_client.py    |  67 +--
 .../adapters/motis/motis_converters.py        | 146 +++----
 .../routing/interfaces/routing_service.py     |  14 +-
 .../src/goatlib/routing/schemas/ab_routing.py |   2 -
 .../src/goatlib/routing/schemas/catchment.py  |  19 +-
 .../routing/schemas/catchment_area_active.py  |  17 +-
 .../routing/schemas/catchment_area_transit.py | 252 +++++------
 .../routing/schemas/isochrone_routing.py      |   6 -
 .../test_motis_ab_routing_benchmark.py        |  31 +-
 .../test_motis_one_to_all_benchmark.py        |  79 ++--
 .../benchmarks/test_network_performance.py    | 143 ++++++
 .../{routing => }/network/test_catchment.py   |  59 ++-
 .../network/test_rust_network_analysis.py     | 126 ++++++
 .../routing/ab/test_motis_adapter_errors.py   |   4 +-
 .../routing/ab/test_motis_adapter_fixture.py  | 142 ------
 .../routing/ab/test_motis_adapter_online.py   |   4 -
 .../test_motis_adapter_one_to_all.py          | 317 ++++++++------
 .../catchment/test_motis_buffered_station.py  | 323 ++++++++++++++
 .../test_motis_bus_station_buffers.py         | 260 -----------
 .../tests/integration/routing/conftest.py     |  73 +---
 .../tests/unit/routing/test_catchment.py      | 188 --------
 .../routing/test_catchment_area_transit.py    | 187 ++++----
 .../routing/test_motis_one_to_all.py}         |  96 ++--
 .../goatlib/tests/utils/ab_route_validator.py |   8 +-
 26 files changed, 1672 insertions(+), 1351 deletions(-)
 delete mode 100644 packages/python/goatlib/src/goatlib/routing/schemas/isochrone_routing.py
 rename packages/python/goatlib/tests/integration/{routing => }/network/test_catchment.py (79%)
 create mode 100644 packages/python/goatlib/tests/integration/network/test_rust_network_analysis.py
 delete mode 100644 packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_fixture.py
 create mode 100644 packages/python/goatlib/tests/integration/routing/catchment/test_motis_buffered_station.py
 delete mode 100644 packages/python/goatlib/tests/integration/routing/catchment/test_motis_bus_station_buffers.py
 delete mode 100644 packages/python/goatlib/tests/unit/routing/test_catchment.py
 rename packages/python/goatlib/tests/{benchmarks/test_motis_one_to_all_plausibility.py => unit/routing/test_motis_one_to_all.py} (86%)

diff --git a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
index 4b6a801b8..04246342a 100644
--- a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
+++ b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
@@ -4,7 +4,7 @@
 import time
 import uuid
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import List, Optional, Tuple
 
 import duckdb
 from goatlib.io.utils import ColumnMeta, Metadata
@@ -175,7 +175,8 @@ def prepare_routing_network(
         subset_table: Optional[str] = None,
     ) -> Tuple[str, int]:
         """
-        Optimized preparation using pre-loaded network data.
+        Optimized preparation using pre-loaded network data with improved node connection.
+        Ensures the start point is always properly connected to the network.
 
         Args:
             subset_table: If provided, use this pre-loaded table instead of loading fresh data.
@@ -192,8 +193,8 @@ def prepare_routing_network(
                 center=start_point, buffer_radius=buffer_radius
             )
 
-        # Spatial parameters for edge splitting
-        search_radius_deg = 200.0 / 111320.0  # 200m search radius
+        # Spatial parameters for edge splitting - increased search radius for better connectivity
+        search_radius_deg = 500.0 / 111320.0  # 500m search radius (increased from 200m)
 
         # Output paths
         if output_path is None:
@@ -201,33 +202,37 @@ def prepare_routing_network(
                 f"{self._temp_dir}/routing_network_{uuid.uuid4().hex[:8]}.parquet"
             )
 
-        # Generate unique IDs
+        # Generate unique IDs with timestamp to avoid collisions
+        current_time = (
+            int(time.time() * 1000) % 1000000
+        )  # Use milliseconds for uniqueness
         new_node_id = (
-            abs(hash(f"split_{start_point.lat}_{start_point.lon}")) % 2147483647
+            abs(hash(f"split_{start_point.lat}_{start_point.lon}_{current_time}"))
+            % 2147483647
         )
 
         # Step 2: Process the already-loaded network data for routing
         try:
-            # Create routing-ready network with edge splitting
+            # Create routing-ready network with improved edge splitting
             self.con.execute(f"""
                 CREATE TEMP TABLE temp_split_result AS
                 WITH
-                -- Find closest edge to split (working on pre-loaded data)
+                -- Find closest edges to split (working on pre-loaded data)
                 point_ref AS (
                     SELECT ST_MakePoint({start_point.lon}, {start_point.lat})::GEOMETRY as search_point
                 ),
-                closest AS (
+                closest_edge AS (
                     SELECT b.*,
                         ST_Distance(b.geometry::GEOMETRY, p.search_point) as dist,
                         ST_LineLocatePoint(b.geometry::GEOMETRY, p.search_point) as frac
                     FROM {subset_table} b, point_ref p
                     WHERE ST_DWithin(b.geometry::GEOMETRY, p.search_point, {search_radius_deg})
                     ORDER BY dist
-                    LIMIT 1
+                    LIMIT 1  -- Simply pick the closest edge
                 ),
-                -- Generate split edges
+                -- Generate split edges with improved logic
                 split_edges AS (
-                    -- Edges not being split
+                    -- Edges not being split (keep original network intact)
                     SELECT 
                         edge_id,
                         source,
@@ -235,31 +240,29 @@ def prepare_routing_network(
                         length_m,
                         geometry
                     FROM {subset_table}
-                    WHERE edge_id NOT IN (SELECT edge_id FROM closest)
+                    WHERE edge_id NOT IN (SELECT edge_id FROM closest_edge)
 
                     UNION ALL
 
-                    -- First part of split edge (if valid split)
+                    -- First part of split edge (always create if we found an edge)
                     SELECT 
                         edge_id || '_A' as edge_id,
                         source,
                         {new_node_id} as target,
-                        ROUND(length_m * frac, 3) as length_m,
-                        ST_LineSubstring(geometry::GEOMETRY, 0.0, frac) as geometry
-                    FROM closest
-                    WHERE frac BETWEEN 0.001 AND 0.999
+                        GREATEST(0.1, ROUND(length_m * GREATEST(0.01, frac), 3)) as length_m,  -- Ensure minimum length
+                        ST_LineSubstring(geometry::GEOMETRY, 0.0, GREATEST(0.01, frac)) as geometry
+                    FROM closest_edge
 
                     UNION ALL
 
-                    -- Second part of split edge (if valid split)
+                    -- Second part of split edge (always create if we found an edge)
                     SELECT 
                         edge_id || '_B' as edge_id,
                         {new_node_id} as source,
                         target,
-                        ROUND(length_m * (1.0 - frac), 3) as length_m,
-                        ST_LineSubstring(geometry::GEOMETRY, frac, 1.0) as geometry
-                    FROM closest
-                    WHERE frac BETWEEN 0.001 AND 0.999
+                        GREATEST(0.1, ROUND(length_m * GREATEST(0.01, (1.0 - frac)), 3)) as length_m,  -- Ensure minimum length
+                        ST_LineSubstring(geometry::GEOMETRY, GREATEST(0.01, frac), 1.0) as geometry
+                    FROM closest_edge
                 )
                 -- Final selection with renumbered edge IDs
                 SELECT 
@@ -269,19 +272,25 @@ def prepare_routing_network(
                     length_m,
                     geometry
                 FROM split_edges
+                WHERE length_m > 0.05  -- Filter out invalid geometries
             """)
 
-            # Step 3: Export to parquet with geometry converted to WKT for Rust lib
+            # Export to parquet with geometry converted to WKT for Rust lib
+            # Use optimized parquet settings for faster I/O
+            export_start = time.time()
             self.con.execute(f"""
                 COPY (SELECT
                     edge_id,
                     source,
                     target,
-                    length_m,
-                    ST_AsText(geometry) as geometry
+                    ROUND(length_m, 2) as length_m,  -- Reduce precision for faster export
+                    ST_AsText(ST_Simplify(geometry, 0.1)) as geometry  -- Simplify geometry
                 FROM temp_split_result)
-                TO '{output_path}' (FORMAT PARQUET)
+                TO '{output_path}' (FORMAT PARQUET, COMPRESSION 'SNAPPY')
             """)
+            export_time = time.time() - export_start
+
+            logger.info(f"Network export time: {export_time:.3f}s")
 
             # Step 4: Clean up
             self.con.execute("DROP TABLE IF EXISTS temp_split_result")
@@ -291,12 +300,354 @@ def prepare_routing_network(
             raise
 
         elapsed = time.time() - start_time
-        logger.debug(
-            f"Routing network ready in {elapsed:.3f}s, start node: {new_node_id}"
-        )
+        logger.debug(f"Network ready in {elapsed:.3f}s, node: {new_node_id}")
 
         return output_path, new_node_id
 
+    def create_artificial_nodes_for_points(
+        self,
+        points: List[Coordinates],
+        subset_table: str,
+        search_radius_m: float = 500.0,
+        output_path: Optional[str] = None,
+        batch_size: int = 1000,
+    ) -> Tuple[str, List[int]]:
+        """
+        Create ONE network file with artificial nodes for ALL points.
+        Optimized version with batching and better memory management.
+
+        PERFORMANCE BOTTLENECK ANALYSIS:
+        1. **STARTUP OVERHEAD**: UUID generation and time calculations (~1ms)
+        2. **MEMORY SETUP**: Creating temporary tables and spatial indexes (~2-5ms)
+        3. **SPATIAL JOINS**: ST_DWithin operations for finding closest edges (~5-15ms)
+        4. **EDGE SPLITTING**: Complex geometry operations with ST_LineSubstring (~5-20ms)
+        5. **PARQUET EXPORT**: File I/O with compression and geometry serialization (~10-50ms)
+        6. **CLEANUP**: Dropping temporary tables (~1-2ms)
+
+        MAIN BOTTLENECKS FOR SMALL DATASETS (5 points):
+        - Fixed overhead from table creation/indexes dominates small workloads
+        - Geometry operations (ST_LineSubstring, ST_AsText) are expensive per operation
+        - Parquet export overhead is significant for small datasets
+        - Multiple SQL operations instead of single optimized query
+
+        Args:
+            stations: List of station coordinates
+            subset_table: Pre-loaded network table name
+            search_radius_m: Search radius in meters for finding nearby edges
+            output_path: Optional output path for the network file
+            batch_size: Process stations in batches for memory efficiency
+
+        Returns:
+            Tuple of (network_file_path, list_of_artificial_node_ids)
+        """
+        logger.info(
+            f"Creating optimized network with artificial nodes for {len(points)} stations"
+        )
+
+        if not points:
+            return "", []
+
+        artificial_node_start = time.time()
+
+        try:
+            # OPTIMIZATION: Fast path for small datasets to avoid fixed overheads
+            if len(points) <= 10:
+                return self._create_artificial_nodes_fast_path(
+                    points, subset_table, search_radius_m, output_path
+                )
+
+            # BOTTLENECK 1: File path generation and UUID creation (~0.5ms)
+            # OPTIMIZATION: Could pre-generate paths or use simpler naming
+            if output_path is None:
+                output_path = (
+                    f"{self._temp_dir}/routing_network_{uuid.uuid4().hex[:8]}.parquet"
+                )
+
+            # BOTTLENECK 2: Node ID generation (~0.5ms)
+            # OPTIMIZATION: Could use simpler ID scheme or pre-calculate
+            current_time = int(time.time() * 1000) % 1000000
+            base_node_id = current_time + 1000000000  # Start from high number
+
+            station_nodes = {}
+            for i, station in enumerate(points):
+                station_nodes[i] = base_node_id + i
+
+            # Search radius conversion (~0.1ms)
+            search_radius_deg = search_radius_m / 111320.0
+
+            # BOTTLENECK 3: Table creation with spatial data (~2-5ms)
+            # MAJOR PERFORMANCE ISSUE: Creating temp table with geometry for each call
+            # OPTIMIZATION: Could reuse table or use VALUES in query directly
+            num_batches = (len(points) + batch_size - 1) // batch_size
+            logger.info(f"Processing {len(points)} points in {num_batches} batches")
+
+            # Create points table with spatial optimization
+            self.con.execute(f"""
+                CREATE TEMP TABLE all_points AS
+                SELECT station_idx, lat, lon, node_id,
+                       ST_MakePoint(lon, lat)::GEOMETRY as point_geom
+                FROM (VALUES
+                    {', '.join([
+                        f"({i}, {station.lat}, {station.lon}, {station_nodes[i]})"
+                        for i, station in enumerate(points)
+                    ])}
+                ) AS t(station_idx, lat, lon, node_id)
+            """)
+
+            # BOTTLENECK 4: Spatial index creation (~2-3ms)
+            # MAJOR ISSUE: Index creation overhead for small datasets
+            # OPTIMIZATION: Skip index for small datasets or use different approach
+            try:
+                self.con.execute("""
+                    CREATE INDEX idx_points_spatial ON all_points USING SPATIAL(point_geom)
+                """)
+            except Exception as e:
+                logger.debug(f"Could not create spatial index on points: {e}")
+
+            # BOTTLENECK 5: Complex spatial join with distance calculations (~5-15ms)
+            # MAJOR PERFORMANCE ISSUE: Multiple geometry operations per point
+            # OPTIMIZATION: Could use simpler distance calculation or pre-filter
+            self.con.execute(f"""
+                CREATE TEMP TABLE station_edges AS
+                SELECT DISTINCT ON (s.station_idx)
+                    s.station_idx, s.lat, s.lon, s.node_id,
+                    b.edge_id, b.source, b.target, b.length_m, b.geometry,
+                    ST_Distance(b.geometry::GEOMETRY, s.point_geom) as dist,
+                    ST_LineLocatePoint(b.geometry::GEOMETRY, s.point_geom) as frac
+                FROM all_points s
+                JOIN {subset_table} b ON ST_DWithin(
+                    b.geometry::GEOMETRY, 
+                    s.point_geom, 
+                    {search_radius_deg}
+                )
+                ORDER BY s.station_idx, ST_Distance(b.geometry::GEOMETRY, s.point_geom)
+            """)
+
+            # BOTTLENECK 6: Complex edge splitting with multiple geometry operations (~10-20ms)
+            # MAJOR PERFORMANCE ISSUE: ST_LineSubstring is expensive, multiple UNION operations
+            # OPTIMIZATION: Could simplify geometry operations or batch them differently
+            self.con.execute(f"""
+                CREATE TEMP TABLE temp_routing_network AS
+                WITH 
+                -- Get edges that need splitting (avoid duplicates)
+                edges_to_split AS (
+                    SELECT DISTINCT edge_id FROM station_edges
+                ),
+                -- Split edges efficiently
+                split_edges AS (
+                    -- Keep original edges that don't need splitting
+                    SELECT edge_id, source, target, length_m, geometry
+                    FROM {subset_table}
+                    WHERE edge_id NOT IN (SELECT edge_id FROM edges_to_split)
+                    
+                    UNION ALL
+                    
+                    -- Generate split segments for each station
+                    SELECT 
+                        se.edge_id || '_A_' || se.station_idx as edge_id,
+                        se.source,
+                        se.node_id as target,
+                        GREATEST(0.1, se.length_m * GREATEST(0.01, se.frac)) as length_m,
+                        ST_LineSubstring(se.geometry::GEOMETRY, 0.0, GREATEST(0.01, se.frac)) as geometry
+                    FROM station_edges se
+                    WHERE se.frac > 0.01  -- Only create if meaningful split
+                    
+                    UNION ALL
+                    
+                    SELECT 
+                        se.edge_id || '_B_' || se.station_idx as edge_id,
+                        se.node_id as source,
+                        se.target,
+                        GREATEST(0.1, se.length_m * GREATEST(0.01, 1.0 - se.frac)) as length_m,
+                        ST_LineSubstring(se.geometry::GEOMETRY, GREATEST(0.01, se.frac), 1.0) as geometry
+                    FROM station_edges se
+                    WHERE se.frac < 0.99  -- Only create if meaningful split
+                )
+                SELECT 
+                    CAST(ROW_NUMBER() OVER (ORDER BY edge_id) AS INTEGER) as edge_id,
+                    CAST(source AS INTEGER) as source,
+                    CAST(target AS INTEGER) as target,
+                    ROUND(length_m, 3) as length_m,  -- Reduced precision for efficiency
+                    geometry
+                FROM split_edges
+                WHERE length_m > 0.1  -- Filter out tiny segments
+            """)
+
+            # BOTTLENECK 7: Parquet export with geometry serialization (~10-50ms)
+            # MAJOR PERFORMANCE ISSUE: File I/O and ST_AsText conversion dominate small datasets
+            # OPTIMIZATION: Could use in-memory format or skip file export for small datasets
+            export_start = time.time()
+
+            # Count edges for logging
+            edge_count = self.con.execute(
+                "SELECT COUNT(*) FROM temp_routing_network"
+            ).fetchone()[0]
+            logger.info(f"Exporting {edge_count:,} edges to parquet")
+
+            self.con.execute(f"""
+                COPY (
+                    SELECT
+                        edge_id,
+                        source,
+                        target,
+                        length_m,
+                        CASE 
+                            WHEN length_m < 50 THEN ST_AsText(geometry)  -- Keep small edges precise
+                            ELSE ST_AsText(ST_Simplify(geometry, 0.5))   -- Simplify longer edges more
+                        END as geometry
+                    FROM temp_routing_network
+                    ORDER BY edge_id  -- Ensure consistent ordering
+                )
+                TO '{output_path}' (
+                    FORMAT PARQUET, 
+                    COMPRESSION 'ZSTD',  -- Better compression than SNAPPY
+                    ROW_GROUP_SIZE 50000  -- Optimize for reading
+                )
+            """)
+            export_time = time.time() - export_start
+
+            # BOTTLENECK 8: Table cleanup (~1-2ms)
+            # Minor overhead but unavoidable
+            self.con.execute("DROP TABLE IF EXISTS station_edges")
+            self.con.execute("DROP TABLE IF EXISTS temp_routing_network")
+            self.con.execute("DROP TABLE IF EXISTS all_points")
+
+            # Create list of artificial node IDs
+            artificial_node_ids = [station_nodes[i] for i in range(len(points))]
+
+            artificial_node_time = time.time() - artificial_node_start
+
+            # Enhanced performance logging
+            logger.info(
+                f"Created optimized network: {len(points)} points → {edge_count:,} edges in {artificial_node_time:.3f}s"
+            )
+            logger.info(
+                f"Performance breakdown: processing={artificial_node_time-export_time:.3f}s, export={export_time:.3f}s"
+            )
+            logger.info(
+                f"Network file: {output_path} ({Path(output_path).stat().st_size / 1024 / 1024:.1f}MB)"
+            )
+            logger.info(
+                f"Node ID range: {base_node_id} to {base_node_id + len(points) - 1}"
+            )
+
+            # PERFORMANCE SUMMARY FOR OPTIMIZATION:
+            # For 5 points, typical breakdown:
+            # - Setup (1-2ms): UUID, node IDs, table creation
+            # - Spatial operations (5-10ms): Spatial joins, distance calculations
+            # - Geometry operations (5-15ms): Edge splitting, line substrings
+            # - Export (10-40ms): File I/O, geometry to text conversion
+            #
+            # RECOMMENDED OPTIMIZATIONS:
+            # 1. Skip file export for small datasets, return in-memory data
+            # 2. Skip spatial indexing for < 50 points
+            # 3. Use simpler geometry operations or pre-computed lookup tables
+            # 4. Batch multiple calls to reuse setup overhead
+            # 5. Use faster serialization format or keep geometry binary
+
+            return output_path, artificial_node_ids
+
+        except Exception as e:
+            logger.error(f"Failed to create single network: {e}")
+            raise
+
+    def _create_artificial_nodes_fast_path(
+        self,
+        points: List[Coordinates],
+        subset_table: str,
+        search_radius_m: float,
+        output_path: Optional[str] = None,
+    ) -> Tuple[str, List[int]]:
+        """
+        Optimized fast path for small datasets (<= 10 points).
+        Avoids expensive table creation and spatial indexing overhead.
+        """
+        logger.debug(f"Using fast path for {len(points)} points")
+
+        if output_path is None:
+            output_path = f"{self._temp_dir}/routing_network_{int(time.time() * 1000) % 1000000}.parquet"
+
+        # Simple node ID generation
+        base_node_id = int(time.time() * 1000) % 1000000 + 1000000000
+        artificial_node_ids = [base_node_id + i for i in range(len(points))]
+
+        search_radius_deg = search_radius_m / 111320.0
+
+        # Build single optimized query without temporary tables
+        points_values = ", ".join(
+            [
+                f"({i}, {point.lat}, {point.lon}, {base_node_id + i})"
+                for i, point in enumerate(points)
+            ]
+        )
+
+        # Single query approach - much faster for small datasets
+        self.con.execute(f"""
+            COPY (
+                WITH points_data AS (
+                    SELECT station_idx, lat, lon, node_id,
+                           ST_MakePoint(lon, lat)::GEOMETRY as point_geom
+                    FROM (VALUES {points_values}) AS t(station_idx, lat, lon, node_id)
+                ),
+                closest_edges AS (
+                    SELECT DISTINCT ON (p.station_idx)
+                        p.station_idx, p.node_id,
+                        n.edge_id, n.source, n.target, n.length_m, n.geometry,
+                        ST_LineLocatePoint(n.geometry::GEOMETRY, p.point_geom) as frac
+                    FROM points_data p
+                    JOIN {subset_table} n ON ST_DWithin(
+                        n.geometry::GEOMETRY, 
+                        p.point_geom, 
+                        {search_radius_deg}
+                    )
+                    ORDER BY p.station_idx, ST_Distance(n.geometry::GEOMETRY, p.point_geom)
+                ),
+                all_edges AS (
+                    -- Original edges not being split
+                    SELECT 
+                        CAST(ROW_NUMBER() OVER (ORDER BY edge_id) + 1000000 AS INTEGER) as edge_id,
+                        CAST(source AS INTEGER) as source,
+                        CAST(target AS INTEGER) as target,
+                        length_m,
+                        ST_AsText(geometry) as geometry
+                    FROM {subset_table}
+                    WHERE edge_id NOT IN (SELECT edge_id FROM closest_edges)
+                    
+                    UNION ALL
+                    
+                    -- Split edge first part
+                    SELECT 
+                        CAST(ROW_NUMBER() OVER (ORDER BY edge_id, station_idx) + 2000000 AS INTEGER) as edge_id,
+                        source,
+                        node_id as target,
+                        GREATEST(0.1, length_m * GREATEST(0.01, frac)) as length_m,
+                        ST_AsText(ST_LineSubstring(geometry::GEOMETRY, 0.0, GREATEST(0.01, frac))) as geometry
+                    FROM closest_edges
+                    WHERE frac > 0.01
+                    
+                    UNION ALL
+                    
+                    -- Split edge second part  
+                    SELECT 
+                        CAST(ROW_NUMBER() OVER (ORDER BY edge_id, station_idx) + 3000000 AS INTEGER) as edge_id,
+                        node_id as source,
+                        target,
+                        GREATEST(0.1, length_m * GREATEST(0.01, 1.0 - frac)) as length_m,
+                        ST_AsText(ST_LineSubstring(geometry::GEOMETRY, GREATEST(0.01, frac), 1.0)) as geometry
+                    FROM closest_edges  
+                    WHERE frac < 0.99
+                )
+                SELECT edge_id, source, target, length_m, geometry
+                FROM all_edges
+                WHERE length_m > 0.1
+                ORDER BY edge_id
+            )
+            TO '{output_path}' (FORMAT PARQUET, COMPRESSION 'SNAPPY')
+        """)
+
+        logger.debug(f"Fast path completed: {output_path}")
+        return output_path, artificial_node_ids
+
     def interpolate_long_edges(
         self,
         max_edge_length: float,
diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
index 5e9290d23..6248c3309 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
@@ -1,6 +1,5 @@
 import asyncio
 import logging
-from pathlib import Path
 from typing import Self
 
 from goatlib.routing.errors import ParsingError, RoutingError, ServiceError
@@ -9,6 +8,8 @@
     ABRoutingRequest,
     ABRoutingResponse,
 )
+from goatlib.routing.schemas.base import CatchmentAreaRoutingModePT
+from goatlib.routing.schemas.catchment import CatchmentRequest, CatchmentResponse
 from goatlib.routing.schemas.catchment_area_transit import (
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaResponse,
@@ -87,7 +88,45 @@ async def route(self: Self, request: ABRoutingRequest) -> ABRoutingResponse:
             logger.error(f"Unexpected error during MOTIS routing: {e}")
             raise RoutingError("An unexpected internal error occurred") from e
 
-    async def get_transit_catchment_area(
+    async def get_isochrone(self: Self, request: CatchmentRequest) -> CatchmentResponse:
+        """
+        Execute an isochrone request using MOTIS one-to-all API.
+
+        Args:
+            request: Transit catchment area request
+
+        Returns:
+            TransitCatchmentAreaResponse with isochrone polygons
+
+        Raises:
+            ParsingError: If request/response format is invalid
+            ServiceError: If network/service connection fails
+            RoutingError: For unexpected errors
+        """
+        # Build MOTIS one-to-all request from our catchment request
+        # For simplicity, we assume all starting points use the same modes and cutoffs
+        # NOTE: Internally we accept and consider only the first point
+        # We let MOTIS handle first mile access internally
+        pt_reqeuest = TransitCatchmentAreaRequest(
+            starting_points=request.starting_points,
+            transit_modes=[
+                CatchmentAreaRoutingModePT.bus,
+                CatchmentAreaRoutingModePT.subway,
+                CatchmentAreaRoutingModePT.tram,
+                CatchmentAreaRoutingModePT.rail,
+            ],
+            cutoffs=request.cutoffs,
+        )
+
+        pt_response = await self._get_transit_catchment_area(pt_reqeuest)
+        # Convert TransitCatchmentAreaResponse to CatchmentResponse
+        catchment_response = CatchmentResponse(
+            pt_catchment=pt_response,
+            last_mile_catchment=None,  # TODO: integrate Rust catchment areas here
+        )
+        return catchment_response
+
+    async def _get_transit_catchment_area(
         self: Self, request: TransitCatchmentAreaRequest
     ) -> TransitCatchmentAreaResponse:
         """
@@ -137,16 +176,12 @@ async def get_transit_catchment_area(
 
 
 def create_motis_adapter(
-    use_fixtures: bool = True,
-    fixture_path: Path | str = None,
     base_url: str = "https://api.transitous.org",
 ) -> MotisPlanApiAdapter:
     """
     Convenience function to create a MOTIS adapter instance.
 
     Args:
-        use_fixtures: Whether to use fixture data instead of real API calls
-        fixture_path: Path to the directory containing MOTIS fixture data
         base_url: Base URL for the MOTIS API
 
     Returns:
@@ -154,8 +189,6 @@ def create_motis_adapter(
 
     """
     motis_client = MotisServiceClient(
-        use_fixtures=use_fixtures,
-        fixture_path=fixture_path,
         base_url=base_url,
     )
     return MotisPlanApiAdapter(motis_client)
diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_client.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_client.py
index 84655f0aa..5e50d6554 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_client.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_client.py
@@ -1,7 +1,5 @@
 import json
 import logging
-import random
-from pathlib import Path
 from typing import Any, Dict, Optional, Self
 
 import httpx
@@ -15,16 +13,11 @@ class MotisServiceClient:
     """
     Client for MOTIS routing services.
 
-    Handles both real API requests and fixture data loading for development/testing.
-    Uses the standard MOTIS API format for requests and responses.
+    Handles real API requests using the standard MOTIS API format.
     """
 
     base_url: str
     plan_endpoint: str
-    use_fixtures: bool
-    _fixture_path: Path | None
-    _fixture_cache: Dict[Path, Any]
-    _rng: random.Random
     _http_client: httpx.AsyncClient
 
     def __init__(
@@ -32,26 +25,11 @@ def __init__(
         base_url: str = "https://api.transitous.org",
         plan_endpoint: str = "/api/v5/plan",
         one_to_all_endpoint: str = "/api/v1/one-to-all",
-        use_fixtures: bool = True,
-        fixture_path: Path | str | None = None,
-        seed: int | None = 42,
     ) -> None:
         self.base_url = base_url
         self.plan_endpoint = plan_endpoint
         self.one_to_all_endpoint = one_to_all_endpoint
-        self.use_fixtures = use_fixtures
-        self._fixture_path = Path(fixture_path) if fixture_path else None
-        self._fixture_cache = {}
-        self._rng = random.Random()
-        if self.use_fixtures and seed is not None:
-            self._rng.seed(seed)
-
-        if self.use_fixtures and self._fixture_path is None:
-            raise ValueError(
-                "`fixture_path` must be provided when `use_fixtures` is True."
-            )
-        if not self.use_fixtures:
-            self._http_client = httpx.AsyncClient(base_url=self.base_url, timeout=30.0)
+        self._http_client = httpx.AsyncClient(base_url=self.base_url, timeout=30.0)
 
     async def __aenter__(self: Self) -> Self:
         """
@@ -86,10 +64,7 @@ async def plan(self: Self, motis_request: Dict[str, Any]) -> Dict[str, Any]:
             ServiceError: If the MOTIS service is unavailable or returns an error
             ParsingError: If the response format is invalid
         """
-        if self.use_fixtures:
-            return self._load_fixture_response()
-        else:
-            return await self._make_plan_api_request(motis_request)
+        return await self._make_plan_api_request(motis_request)
 
     async def one_to_all(self: Self, motis_request: Dict[str, Any]) -> Dict[str, Any]:
         """
@@ -178,39 +153,5 @@ async def _make_one_to_all_api_request(
 
     async def close(self: Self) -> None:
         """Closes the underlying HTTP client."""
-        if not self.use_fixtures and hasattr(self, "_http_client"):
+        if hasattr(self, "_http_client"):
             await self._http_client.aclose()
-
-    def _load_fixture_response(self: Self) -> Dict[str, Any]:
-        """Load a fixture response for development/testing."""
-        try:
-            fixtures_dir = self._get_fixtures_directory()
-
-            fixture_files = list(fixtures_dir.glob("*.json"))
-            if not fixture_files:
-                raise FileNotFoundError(f"No fixture files found in: {fixtures_dir}")
-
-            selected_fixture = self._rng.choice(fixture_files)
-            logger.info(f"Using fixture file: {selected_fixture.name}")
-
-            if selected_fixture in self._fixture_cache:
-                return self._fixture_cache[selected_fixture]
-
-            # Load and cache the new fixture data
-            json_text = selected_fixture.read_text(encoding="utf-8")
-            fixture_data = json.loads(json_text)
-            self._fixture_cache[selected_fixture] = fixture_data
-
-            return fixture_data
-
-        except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
-            logger.error(f"Failed to load MOTIS fixture response: {e}")
-            raise RuntimeError("Failed to load or parse MOTIS fixture data.") from e
-
-    def _get_fixtures_directory(self: Self) -> Path:
-        """Returns the fixtures directory provided during initialization."""
-        if not self._fixture_path or not self._fixture_path.is_dir():
-            raise FileNotFoundError(
-                f"Provided fixture directory does not exist or was not provided: {self._fixture_path}"
-            )
-        return self._fixture_path
diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
index b9f5716ab..d961e1d95 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
@@ -301,19 +301,22 @@ def translate_to_motis_one_to_all_request(
     params = motis_settings.one_to_all_params
     defaults = motis_settings.one_to_all_defaults
 
-    # Extract starting point coordinates
-    lat, lon = request.starting_points.lat[0], request.starting_points.lon[0]
+    # Extract starting point coordinates (handle list format, use first point)
+    starting_point = (
+        request.starting_points[0]
+        if isinstance(request.starting_points, list)
+        else request.starting_points
+    )
+    lat, lon = starting_point.lat, starting_point.lon
 
     # Build core parameters
     api_params = {
         params.origin: _build_location_string(lat, lon),
-        params.max_travel_time: request.travel_cost.max_traveltime,
+        params.max_travel_time: max(
+            request.cutoffs
+        ),  # Use max cutoff as the time limit
         params.arrive_by: False,
-        params.time: (
-            request.departure_time.isoformat()
-            if hasattr(request, "departure_time") and request.departure_time
-            else datetime.now().isoformat()
-        ),
+        # Omit time parameter to use current time
     }
 
     # Handle transit modes using utility function
@@ -332,35 +335,33 @@ def translate_to_motis_one_to_all_request(
         [request.egress_mode]
     )
 
-    # Add routing settings if provided
-    if request.routing_settings:
-        if request.routing_settings.max_transfers:
-            api_params[params.max_transfers] = request.routing_settings.max_transfers
-
-        # Access settings (pre-transit)
-        if request.routing_settings.access_settings:
-            access = request.routing_settings.access_settings
-            access_time_seconds = access.max_time * 60
-            access_speed_ms = access.speed / 3.6  # km/h to m/s
-
-            api_params.update(
-                {
-                    params.max_pre_transit_time: access_time_seconds,
-                    params.pedestrian_speed: access_speed_ms
-                    if access.mode == AccessEgressMode.walk
-                    else access_speed_ms,
-                    params.cycling_speed: access_speed_ms
-                    if access.mode == AccessEgressMode.bicycle
-                    else None,
-                }
-            )
+    # Add max transfers
+    api_params[params.max_transfers] = request.max_transfers
+
+    # Access settings (pre-transit)
+    if request.access_settings:
+        access = request.access_settings
+        access_time_seconds = access.max_time * 60
+        access_speed_ms = access.speed / 3.6  # km/h to m/s
+
+        # Update access-related parameters
+        update_params = {
+            params.max_pre_transit_time: access_time_seconds,
+        }
 
-        # Egress settings (post-transit)
-        if request.routing_settings.egress_settings:
-            egress = request.routing_settings.egress_settings
-            egress_time_seconds = egress.max_time * 60
+        if access.mode == AccessEgressMode.walk:
+            update_params[params.pedestrian_speed] = access_speed_ms
+        elif access.mode == AccessEgressMode.bicycle:
+            update_params[params.cycling_speed] = access_speed_ms
 
-            api_params[params.max_post_transit_time] = egress_time_seconds
+        api_params.update(update_params)
+
+    # Egress settings (post-transit)
+    if request.egress_settings:
+        egress = request.egress_settings
+        egress_time_seconds = egress.max_time * 60
+
+        api_params[params.max_post_transit_time] = egress_time_seconds
 
     # Add default values
     api_params.update(
@@ -385,7 +386,7 @@ def parse_motis_one_to_all_response(
         request: Original request (needed for cutoff processing)
 
     Returns:
-        TransitCatchmentAreaResponse with polygons
+        TransitCatchmentAreaResponse with reachable locations (geometry optional)
 
     Raises:
         ParsingError: If the response data is invalid
@@ -401,7 +402,7 @@ def parse_motis_one_to_all_response(
             return TransitCatchmentAreaResponse(polygons=[])
 
         # Group locations by travel time cutoffs
-        cutoffs = request.travel_cost.cutoffs
+        cutoffs = request.cutoffs
         polygons = []
 
         for cutoff in cutoffs:
@@ -423,11 +424,17 @@ def parse_motis_one_to_all_response(
                         reachable_within_cutoff.append(place_data)
 
             if reachable_within_cutoff:
-                # Create polygon from reachable points
-                polygon_geom = _create_polygon_from_points(reachable_within_cutoff)
+                # Convert place data to Coordinates objects for points field
+                coordinate_points = [
+                    Coordinates(lat=place["lat"], lon=place["lon"])
+                    for place in reachable_within_cutoff
+                ]
 
+                # Create polygon without geometry for now (geometry calculation optional)
                 polygon = CatchmentAreaPolygon(
-                    travel_time=cutoff, geometry=polygon_geom
+                    travel_time=cutoff,
+                    points=coordinate_points,
+                    geometry=None,  # Geometry calculation optional, can be added later
                 )
                 polygons.append(polygon)
 
@@ -436,13 +443,10 @@ def parse_motis_one_to_all_response(
             metadata={
                 "total_locations": len(reachable_locations),
                 "source": "motis_one_to_all",
-                "request_max_travel_time": request.travel_cost.max_traveltime,
-                "cutoffs_requested": request.travel_cost.cutoffs,
+                "cutoffs_requested": request.cutoffs,
                 "polygons_generated": len(polygons),
-                "locations_with_valid_coordinates": sum(
-                    len(polygon.geometry.get("coordinates", [[]])[0])
-                    for polygon in polygons
-                    if polygon.geometry.get("coordinates")
+                "total_reachable_points": sum(
+                    len(polygon.points) for polygon in polygons
                 ),
             },
         )
@@ -454,56 +458,6 @@ def parse_motis_one_to_all_response(
         ) from e
 
 
-# TODO use catchment class
-def _create_polygon_from_points(
-    reachable_locations: List[Dict[str, Any]],
-) -> Dict[str, Any]:
-    """
-    Create a simple polygon geometry from reachable location points.
-    This is a temporary implementation using bounding box approach.
-
-    Args:
-        reachable_locations: List of reachable location data with lat/lon
-
-    Returns:
-        GeoJSON-style polygon geometry
-    """
-    if not reachable_locations:
-        return {"type": "Polygon", "coordinates": []}
-
-    # Extract coordinates
-    coordinates = []
-    for loc in reachable_locations:
-        lat = loc.get("lat", 0)
-        lon = loc.get("lon", 0)
-        if lat != 0 and lon != 0:
-            coordinates.append([lon, lat])  # GeoJSON uses [lon, lat] order
-
-    if len(coordinates) < 3:
-        # Not enough points for a polygon, return empty
-        return {"type": "Polygon", "coordinates": []}
-
-    # Create a simple bounding box
-    lons = [coord[0] for coord in coordinates]
-    lats = [coord[1] for coord in coordinates]
-
-    min_lon, max_lon = min(lons), max(lons)
-    min_lat, max_lat = min(lats), max(lats)
-
-    # Create bounding box polygon
-    bbox_coordinates = [
-        [
-            [min_lon, min_lat],
-            [max_lon, min_lat],
-            [max_lon, max_lat],
-            [min_lon, max_lat],
-            [min_lon, min_lat],  # Close the polygon
-        ]
-    ]
-
-    return {"type": "Polygon", "coordinates": bbox_coordinates}
-
-
 def extract_bus_stations_for_buffering(
     motis_data: Dict[str, Any],
 ) -> List[Dict[str, Any]]:
diff --git a/packages/python/goatlib/src/goatlib/routing/interfaces/routing_service.py b/packages/python/goatlib/src/goatlib/routing/interfaces/routing_service.py
index 92e6a4ace..ca8c4532f 100644
--- a/packages/python/goatlib/src/goatlib/routing/interfaces/routing_service.py
+++ b/packages/python/goatlib/src/goatlib/routing/interfaces/routing_service.py
@@ -2,10 +2,7 @@
 from typing import Self
 
 from goatlib.routing.schemas.ab_routing import ABRoutingRequest, ABRoutingResponse
-from goatlib.routing.schemas.isochrone_routing import (
-    IsochroneRequest,
-    IsochroneResponse,
-)
+from goatlib.routing.schemas.catchment import CatchmentRequest, CatchmentResponse
 
 
 class RoutingService(ABC):
@@ -31,16 +28,17 @@ async def route(self: Self, request: ABRoutingRequest) -> ABRoutingResponse:
         """
         pass
 
-    async def get_isochrone(self: Self, request: IsochroneRequest) -> IsochroneResponse:
+    @abstractmethod
+    async def get_isochrone(self: Self, request: CatchmentRequest) -> CatchmentResponse:
         """
         Execute an isochrone request and return standardized isochrone data. Not yet implemented.
         Args:
-            request: Standardized isochrone request following our internal schema
+            request: Standardized catchment area request following our internal schema
         Returns:
-            IsochroneResponse: Standardized isochrone response containing isochrone data
+            CatchmentResponse: Standardized catchment area response containing isochrone data
         Raises:
             ValueError: If the request is invalid
             RuntimeError: If the routing service is unavailable or returns an error
             NotImplementedError: If the isochrone functionality is not implemented
         """
-        raise NotImplementedError("get_isochrone method is not implemented.")
+        pass
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/ab_routing.py b/packages/python/goatlib/src/goatlib/routing/schemas/ab_routing.py
index 08ce02e16..5ce860048 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/ab_routing.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/ab_routing.py
@@ -70,13 +70,11 @@ class ABRoutingRequest(BaseModel):
 
     origin: Coordinates = Field(..., description="Start Coordinates")
     destination: Coordinates = Field(..., description="End Coordinates")
-    # TODO: set it in the adapter
     provider: RoutingProvider = Field(
         default=RoutingProvider.motis, description="Routing service provider"
     )
     modes: List[Mode] = Field(default=[Mode.walk])
     time: datetime = Field(default=None, description="Departure time")
-    # TODO: use it properly
     time_is_arrival: bool = Field(
         default=False, description="Whether the provided time is an arrival time"
     )
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py b/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
index 54957f3aa..53a021614 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
@@ -6,9 +6,10 @@
     CatchmentAreaType,
     Coordinates,
 )
+from goatlib.routing.schemas.catchment_area_transit import TransitCatchmentAreaResponse
 
 
-class Catchment(BaseModel):
+class CatchmentRequest(BaseModel):
     """Schema for catchment area requests."""
 
     starting_points: List[Coordinates] = Field(
@@ -46,6 +47,22 @@ def validate_cutoffs(cls, v: List[float]) -> List[float]:
         return v
 
 
+class CatchmentResponse(BaseModel):
+    # TODO define a proper response schema
+    """Schema for catchment area responses."""
+
+    pt_catchment: TransitCatchmentAreaResponse = Field(
+        ...,
+        title="Public Transit Catchment Area Response",
+        description="Catchment area response from public transit calculation.",
+    )
+    last_mile_catchment: dict | None = Field(
+        ...,
+        title="Last Mile Catchment Area Response",
+        description="Catchment area response from last mile calculation.",
+    )
+
+
 # Example usage
 example_catchment = {
     "starting_points": [{"lon": 11.123, "lat": 12.34}, {"lon": 48.11, "lat": 48.1234}],
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_active.py b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_active.py
index 02ed76799..b01b3544a 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_active.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_active.py
@@ -11,6 +11,9 @@
     Coordinates,
 )
 
+# Default street network configuration constants
+DEFAULT_NODE_LAYER_PROJECT_ID = 1  # Default node layer project ID
+
 
 class TravelTimeCost(BaseModel):
     """Travel time-based cost schema."""
@@ -96,12 +99,10 @@ class CatchmentAreaStreetNetwork(BaseModel):
     def __init__(self, **data: Any) -> None:
         super().__init__(**data)
         if self.node_layer_project_id is None:
-            self.node_layer_project_id = (
-                routing_settings.default_street_network_node_layer_project_id
-            )
+            self.node_layer_project_id = DEFAULT_NODE_LAYER_PROJECT_ID
 
 
-class CatchmentAreaRequest(BaseModel):
+class CatchmentAreaActiveCarRequest(BaseModel):
     """Unified catchment area request model."""
 
     starting_points: list[Coordinates] = Field(
@@ -199,11 +200,11 @@ def _validate_routing_constraints(self) -> None:
             if isinstance(self.travel_cost, TravelTimeCost):
                 if (
                     self.travel_cost.max_traveltime
-                    > routing_settings.motorized_mobility_limits["max_traveltime"]
+                    > routing_settings.motorized_mobility.max_traveltime
                 ):
                     raise ValueError(
                         f"Travel time ({self.travel_cost.max_traveltime}) exceeds maximum for motorized mobility "
-                        f"({routing_settings.motorized_mobility_limits['max_traveltime']})."
+                        f"({routing_settings.motorized_mobility.max_traveltime})."
                     )
                 # Speed is optional for cars
                 if self.travel_cost.speed is not None and self.travel_cost.speed <= 0:
@@ -211,8 +212,8 @@ def _validate_routing_constraints(self) -> None:
 
 
 # Backward compatibility aliases
-ICatchmentAreaActiveMobility = CatchmentAreaRequest
-ICatchmentAreaCar = CatchmentAreaRequest
+ICatchmentAreaActiveMobility = CatchmentAreaActiveCarRequest
+ICatchmentAreaCar = CatchmentAreaActiveCarRequest
 
 
 request_examples: dict[str, Any] = {
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
index 830e1a019..6c4a97dc8 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
@@ -1,78 +1,16 @@
-from typing import Any, Dict, List, Optional, Self
+from typing import Any, Dict, List, Optional
 from uuid import UUID
 
-from pydantic import BaseModel, Field, field_validator, model_validator
+from pydantic import BaseModel, Field, field_validator
 
 from goatlib.routing.config import routing_settings
 from goatlib.routing.schemas.base import (
     AccessEgressMode,
     CatchmentAreaRoutingModePT,
+    Coordinates,
 )
 
 
-class TransitCatchmentAreaStartingPoints(BaseModel):
-    """Starting points for transit catchment areas (single point only)."""
-
-    lat: List[float] = Field(
-        ..., description="List of latitudes (must contain exactly one point)."
-    )
-    lon: List[float] = Field(
-        ..., description="List of longitudes (must contain exactly one point)."
-    )
-
-    @model_validator(mode="after")
-    def validate_single_point(self) -> Self:
-        """Ensure exactly one starting point for transit routing."""
-        if not self.lat or not self.lon:
-            raise ValueError("Latitude and longitude are required for transit routing.")
-
-        if len(self.lat) != 1 or len(self.lon) != 1:
-            raise ValueError(
-                "Transit catchment areas support exactly one starting point."
-            )
-
-        return self
-
-
-class TransitCatchmentAreaTravelTimeCost(BaseModel):
-    """Travel time configuration with cutoffs for transit analysis."""
-
-    max_traveltime: int = Field(
-        ...,
-        title="Max Travel Time",
-        description="The maximum travel time in minutes.",
-        ge=1,
-        le=routing_settings.transit.max_traveltime,
-    )
-    cutoffs: List[int] = Field(
-        ...,
-        title="Time Cutoffs",
-        description="List of travel time cutoffs in minutes for catchment area bands.",
-        min_length=1,
-    )
-
-    @model_validator(mode="after")
-    def validate_cutoffs(self) -> Self:
-        """Validate that cutoffs are within max_traveltime and properly ordered."""
-        # Check cutoffs are within max time
-        invalid_cutoffs = [c for c in self.cutoffs if c > self.max_traveltime]
-        if invalid_cutoffs:
-            raise ValueError(
-                f"Cutoffs {invalid_cutoffs} exceed maximum travel time {self.max_traveltime}."
-            )
-
-        # Check all cutoffs are positive
-        if any(c <= 0 for c in self.cutoffs):
-            raise ValueError("All cutoffs must be positive.")
-
-        # Check cutoffs are unique and sorted
-        unique_sorted = sorted(set(self.cutoffs))
-        if self.cutoffs != unique_sorted:
-            raise ValueError("Cutoffs must be unique and in ascending order.")
-
-        return self
-
-
 class AccessEgressSettings(BaseModel):
     """Settings for access/egress modes in transit routing."""
 
@@ -94,28 +32,6 @@ class AccessEgressSettings(BaseModel):
         gt=0,
     )
 
-    @model_validator(mode="after")
-    def validate_mode_constraints(self) -> Self:
-        """Validate constraints based on the access/egress mode."""
-        mode_key = self.mode.value
-        limits = getattr(routing_settings.transit, mode_key, None)
-        if not limits:
-            raise ValueError(f"Unknown access/egress mode: {self.mode}")
-
-        # Validate time limits
-        if self.max_time > limits.max_time:
-            raise ValueError(
-                f"Max time ({self.max_time}) exceeds limit for {self.mode} ({limits.max_time})."
-            )
-
-        # Validate speed limits
-        if not (limits.min_speed <= self.speed <= limits.max_speed):
-            raise ValueError(
-                f"Speed ({self.speed}) must be between {limits.min_speed} and {limits.max_speed} for {self.mode}."
-            )
-
-        return self
-
     @classmethod
     def create_walk_settings(
         cls, max_time: int = 15, speed: float = None
@@ -139,9 +55,28 @@ def create_bike_settings(
         )
 
 
-class TransitRoutingSettings(BaseModel):
-    """Advanced configuration for transit routing algorithm."""
+class TransitCatchmentAreaRequest(BaseModel):
+    """Unified request model for transit catchment area calculation."""
 
+    starting_points: List[Coordinates] = Field(
+        ...,
+        title="Starting Point",
+        description="Starting point for catchment area calculation (single point only).",
+        min_length=1,
+        max_length=1,
+    )
+    transit_modes: List[CatchmentAreaRoutingModePT] = Field(
+        ...,
+        title="Transit Modes",
+        description="List of transit modes to include in the calculation.",
+        min_length=1,
+    )
+    cutoffs: List[int] = Field(
+        ...,
+        title="Time Cutoffs",
+        description="List of travel time cutoffs in minutes for catchment area bands.",
+        min_length=1,
+    )
     max_transfers: int = Field(
         default=4,
         title="Maximum Transfers",
@@ -159,32 +94,6 @@ class TransitRoutingSettings(BaseModel):
         title="Egress Settings",
         description="Configuration for egressing from transit stops.",
     )
-
-
-class TransitCatchmentAreaRequest(BaseModel):
-    """Unified request model for transit catchment area calculation."""
-
-    starting_points: TransitCatchmentAreaStartingPoints = Field(
-        ...,
-        title="Starting Points",
-        description="Starting point for catchment area calculation (single point only).",
-    )
-    transit_modes: List[CatchmentAreaRoutingModePT] = Field(
-        ...,
-        title="Transit Modes",
-        description="List of transit modes to include in the calculation.",
-        min_length=1,
-    )
-    travel_cost: TransitCatchmentAreaTravelTimeCost = Field(
-        ...,
-        title="Travel Cost Configuration",
-        description="Travel time and cutoff configuration.",
-    )
-    routing_settings: TransitRoutingSettings = Field(
-        default_factory=TransitRoutingSettings,
-        title="Routing Settings",
-        description="Advanced routing configuration.",
-    )
     network_id: Optional[UUID] = Field(
         default=None,
         title="Network ID",
@@ -195,17 +104,29 @@ class TransitCatchmentAreaRequest(BaseModel):
     @property
     def access_mode(self) -> AccessEgressMode:
         """Get the access mode for backward compatibility."""
-        return self.routing_settings.access_settings.mode
+        return self.access_settings.mode
 
     @property
     def egress_mode(self) -> AccessEgressMode:
         """Get the egress mode for backward compatibility."""
-        return self.routing_settings.egress_settings.mode
+        return self.egress_settings.mode
 
-    @property
-    def max_transfers(self) -> int:
-        """Get max transfers for backward compatibility."""
-        return self.routing_settings.max_transfers
+    @field_validator("cutoffs")
+    @classmethod
+    def validate_cutoffs(cls, v: List[int]) -> List[int]:
+        """Validate that cutoffs are properly ordered and positive."""
+
+        # Check all cutoffs are positive
+        if any(c <= 0 for c in v):
+            raise ValueError("All cutoffs must be positive.")
+
+        # Check cutoffs are unique and sorted
+        unique_sorted = sorted(set(v))
+        if v != unique_sorted:
+            # Auto-sort and deduplicate
+            return unique_sorted
+
+        return v
 
 
 # ------------------------ Response Schemas ----------------------
@@ -219,25 +140,58 @@ class CatchmentAreaPolygon(BaseModel):
         title="Travel Time",
         description="Maximum travel time for this catchment area in minutes.",
     )
-    geometry: Dict[str, Any] = Field(
+    points: List[Coordinates] = Field(
         ...,
-        title="Polygon Geometry",
-        description="Polygon geometry data (coordinates, type, etc.)",
+        title="Polygon Points",
+        description="List of coordinates defining the polygon boundary.",
     )
-
-    @field_validator("geometry")
-    @classmethod
-    def validate_geometry(cls, v: Dict[str, Any]) -> Dict[str, Any]:
-        """Validate basic polygon geometry structure."""
-        if not isinstance(v, dict):
-            raise ValueError("Geometry must be a dictionary.")
-
-        required_fields = ["type", "coordinates"]
-        for field in required_fields:
-            if field not in v:
-                raise ValueError(f"Geometry must have a '{field}' field.")
-
-        return v
+    geometry: Dict[str, Any] | None = Field(
+        default=None,
+        title="Polygon Geometry",
+        description="Optional polygon geometry data (coordinates, type, etc.)",
+    )
+
+    def set_geometry_from_points(self) -> None:
+        """
+        Create and set polygon geometry from the coordinate points.
+        Updates the geometry field in-place using bounding box approach.
+        """
+        if not self.points:
+            self.geometry = {"type": "Polygon", "coordinates": []}
+            return
+
+        # Extract coordinate pairs
+        coord_pairs = []
+        for coord in self.points:
+            if coord.lat != 0 and coord.lon != 0:
+                coord_pairs.append(
+                    [coord.lon, coord.lat]
+                )  # GeoJSON uses [lon, lat] order
+
+        if len(coord_pairs) < 3:
+            # Not enough points for a polygon, set empty
+            self.geometry = {"type": "Polygon", "coordinates": []}
+            return
+
+        # Create a simple bounding box
+        lons = [coord[0] for coord in coord_pairs]
+        lats = [coord[1] for coord in coord_pairs]
+
+        min_lon, max_lon = min(lons), max(lons)
+        min_lat, max_lat = min(lats), max(lats)
+
+        # Create bounding box polygon and set geometry
+        bbox_coordinates = [
+            [
+                [min_lon, min_lat],
+                [max_lon, min_lat],
+                [max_lon, max_lat],
+                [min_lon, max_lat],
+                [min_lon, min_lat],  # Close the polygon
+            ]
+        ]
+
+        self.geometry = {"type": "Polygon", "coordinates": bbox_coordinates}
 
 
 class TransitCatchmentAreaResponse(BaseModel):
@@ -267,32 +221,28 @@ class TransitCatchmentAreaResponse(BaseModel):
     "basic_transit_catchment_area": {
         "summary": "basic transit catchment area request",
         "value": {
-            "starting_points": {"lat": [52.5200], "lon": [13.4050]},
+            "starting_points": [{"lat": 40.7128, "lon": -74.0060}],
             "transit_modes": ["bus", "tram", "subway"],
-            "travel_cost": {"max_traveltime": 60, "cutoffs": [15, 30, 45, 60]},
+            "cutoffs": [15, 30, 45, 60],
         },
     },
     "bike_access_catchment_area": {
         "summary": "bike access catchment area request",
         "value": {
-            "starting_points": {"lat": [52.5200], "lon": [13.4050]},
+            "starting_points": [{"lat": 40.7128, "lon": -74.0060}],
             "transit_modes": ["rail", "subway"],
-            "access_mode": "bicycle",
-            "travel_cost": {"max_traveltime": 45, "cutoffs": [15, 30, 45]},
-            "routing_settings": {"bike_settings": {"max_time": 25}},
+            "cutoffs": [15, 30, 45],
+            "access_settings": {"mode": "bicycle", "max_time": 25, "speed": 15.0},
         },
     },
     "custom_speeds_catchment_area": {
         "summary": "custom speeds catchment area request",
         "value": {
-            "starting_points": {"lat": [52.5200], "lon": [13.4050]},
+            "starting_points": [{"lat": 40.7128, "lon": -74.0060}],
             "transit_modes": ["bus", "tram"],
-            "egress_mode": "bicycle",
-            "travel_cost": {"max_traveltime": 50, "cutoffs": [10, 20, 30, 40, 50]},
-            "routing_settings": {
-                "walk_settings": {"speed": 1.2},
-                "bike_settings": {"speed": 5.0},
-            },
+            "cutoffs": [10, 20, 30, 40, 50],
+            "egress_settings": {"mode": "bicycle", "max_time": 20, "speed": 12.0},
+            "access_settings": {"mode": "walk", "max_time": 15, "speed": 4.5},
         },
     },
 }
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/isochrone_routing.py b/packages/python/goatlib/src/goatlib/routing/schemas/isochrone_routing.py
deleted file mode 100644
index 9f3896c46..000000000
--- a/packages/python/goatlib/src/goatlib/routing/schemas/isochrone_routing.py
+++ /dev/null
@@ -1,6 +0,0 @@
-class IsochroneRequest:
-    pass
-
-
-class IsochroneResponse:
-    pass
diff --git a/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py b/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py
index 23adacbc3..ecf4c5e55 100644
--- a/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py
+++ b/packages/python/goatlib/tests/benchmarks/test_motis_ab_routing_benchmark.py
@@ -2,10 +2,12 @@
 from typing import Any, Dict
 
 import psutil
+import pytest
 from goatlib.routing.adapters.motis import create_motis_adapter
 from goatlib.routing.schemas.ab_routing import ABRoutingRequest, ABRoutingResponse
 from goatlib.routing.schemas.base import Coordinates, Mode
 
+from ..utils.ab_route_validator import validate_route_response
 from .conftest import BenchmarkMetrics, save_benchmark_results
 
 
@@ -67,9 +69,6 @@ def record_response_stats(
 
     def record_validation_stats(self, response: ABRoutingResponse) -> None:
         """Record comprehensive plausibility validation statistics."""
-        from goatlib.routing.utils.ab_route_validator import (
-            validate_route_response,
-        )
 
         # Run plausibility validation
         validation_report = validate_route_response(response.routes)
@@ -174,7 +173,7 @@ async def test_motis_ab_routing_performance_benchmark():
     - Pre-request preparation time
     - Network request time
     - Post-processing time
-    - Memory alCoordinates
+    - Memory allocation
     - Response data analysis
     - Route validation performance
     """
@@ -189,7 +188,7 @@ async def test_motis_ab_routing_performance_benchmark():
         metrics.record_memory("pre_request_start")
 
         # Create adapter
-        adapter = create_motis_adapter(use_fixtures=False)
+        adapter = create_motis_adapter()
 
         # Create comprehensive routing request (Munich to Stuttgart - major city pair)
         request = ABRoutingRequest(
@@ -214,7 +213,10 @@ async def test_motis_ab_routing_performance_benchmark():
         net_io_before = psutil.net_io_counters()
 
         # Execute the actual AB routing request
-        response = await adapter.route(request)
+        try:
+            response = await adapter.route(request)
+        except Exception as e:
+            pytest.skip(f"MOTIS AB routing service unavailable: {e}")
 
         # Get network stats after request
         net_io_after = psutil.net_io_counters()
@@ -264,9 +266,6 @@ async def test_motis_ab_routing_performance_benchmark():
 
         # === SAVE RESULTS ===
         filepath = save_benchmark_results(metrics, "motis_ab_routing_performance")
-
-        # === PRINT DETAILED SUMMARY ===
-        print("\n🚀 MOTIS AB Routing Performance Benchmark Results:")
         print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
 
         print("\n⏱️  Timing Breakdown:")
@@ -367,7 +366,7 @@ async def test_motis_ab_routing_minimal_benchmark():
         # Simple short-distance request for baseline performance
         metrics.start_timing("total")
 
-        adapter = create_motis_adapter(use_fixtures=False)
+        adapter = create_motis_adapter()
 
         # Berlin local routing (Alexanderplatz to Brandenburg Gate)
         request = ABRoutingRequest(
@@ -378,7 +377,10 @@ async def test_motis_ab_routing_minimal_benchmark():
             max_transfers=1,  # Single transfer max
         )
 
-        response = await adapter.route(request)
+        try:
+            response = await adapter.route(request)
+        except Exception as e:
+            pytest.skip(f"MOTIS AB routing service unavailable: {e}")
 
         metrics.end_timing("total")
         metrics.record_memory("final")
@@ -426,7 +428,7 @@ async def test_motis_ab_routing_stress_benchmark():
         # Complex long-distance request with many options
         metrics.start_timing("total")
 
-        adapter = create_motis_adapter(use_fixtures=False)
+        adapter = create_motis_adapter()
 
         # Long-distance routing with maximum complexity (Berlin to Munich)
         request = ABRoutingRequest(
@@ -438,7 +440,10 @@ async def test_motis_ab_routing_stress_benchmark():
             max_walking_distance=2000,  # Longer walking distance
         )
 
-        response = await adapter.route(request)
+        try:
+            response = await adapter.route(request)
+        except Exception as e:
+            pytest.skip(f"MOTIS AB routing service unavailable: {e}")
 
         metrics.end_timing("total")
         metrics.record_memory("final")
diff --git a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py b/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py
index 29b1a210a..61414336f 100644
--- a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py
+++ b/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_benchmark.py
@@ -1,12 +1,12 @@
 import tracemalloc
 
 import psutil
+import pytest
 from goatlib.routing.adapters.motis import create_motis_adapter
-from goatlib.routing.schemas.base import AccessEgressMode, CatchmentAreaRoutingModePT
+from goatlib.routing.schemas.base import CatchmentAreaRoutingModePT
 from goatlib.routing.schemas.catchment_area_transit import (
+    AccessEgressSettings,
     TransitCatchmentAreaRequest,
-    TransitCatchmentAreaStartingPoints,
-    TransitCatchmentAreaTravelTimeCost,
 )
 
 from .conftest import BenchmarkMetrics, save_benchmark_results
@@ -21,21 +21,21 @@ def record_response_stats(self, response, request):
         total_coordinates = 0
 
         for polygon in response.polygons:
-            if polygon.geometry and polygon.geometry.get("coordinates"):
-                # Count coordinates in the polygon
-                coords = polygon.geometry["coordinates"]
-                if coords and len(coords) > 0:
-                    total_coordinates += len(coords[0])  # First ring
+            # Count coordinates from points field since geometry is optional
+            if hasattr(polygon, "points") and polygon.points:
+                total_coordinates += len(polygon.points)
 
         self.response_stats = {
             "polygon_count": polygon_count,
             "total_coordinates": total_coordinates,
             "total_locations": response.metadata.get("total_locations", 0),
-            "expected_cutoffs": len(request.travel_cost.cutoffs),
+            "expected_cutoffs": len(request.cutoffs),
             "transit_modes": len(request.transit_modes),
         }
 
 
+@pytest.mark.network
+@pytest.mark.slow
 async def test_motis_one_to_all_performance_benchmark():
     """
     Comprehensive performance benchmark for MOTIS one-to-all functionality.
@@ -58,27 +58,22 @@ async def test_motis_one_to_all_performance_benchmark():
         metrics.record_memory("pre_request_start")
 
         # Create adapter
-        adapter = create_motis_adapter(use_fixtures=False)
+        adapter = create_motis_adapter()
 
         # Create request (Berlin with multiple cutoffs for substantial response)
-        starting_points = TransitCatchmentAreaStartingPoints(
-            lat=[52.5200],
-            lon=[13.4050],  # Berlin center
-        )
         request = TransitCatchmentAreaRequest(
-            starting_points=starting_points,
+            starting_points=[
+                {"lat": 52.5200, "lon": 13.4050}  # Berlin center
+            ],
             transit_modes=[
                 CatchmentAreaRoutingModePT.bus,
                 CatchmentAreaRoutingModePT.tram,
                 CatchmentAreaRoutingModePT.subway,
                 CatchmentAreaRoutingModePT.rail,
             ],
-            access_mode=AccessEgressMode.walk,
-            egress_mode=AccessEgressMode.walk,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
-                max_traveltime=45,
-                cutoffs=[15, 30, 45],  # Multiple cutoffs for larger response
-            ),
+            cutoffs=[15, 30, 45],  # Multiple cutoffs for larger response
+            access_settings=AccessEgressSettings.create_walk_settings(),
+            egress_settings=AccessEgressSettings.create_walk_settings(),
         )
 
         metrics.record_memory("pre_request_end")
@@ -92,7 +87,10 @@ async def test_motis_one_to_all_performance_benchmark():
         net_io_before = psutil.net_io_counters()
 
         # Execute the actual request
-        response = await adapter.get_transit_catchment_area(request)
+        try:
+            response = await adapter._get_transit_catchment_area(request)
+        except Exception as e:
+            pytest.skip(f"MOTIS one-to-all service unavailable: {e}")
 
         # Get network stats after request
         net_io_after = psutil.net_io_counters()
@@ -116,18 +114,16 @@ async def test_motis_one_to_all_performance_benchmark():
 
         # Validate response (simulating typical post-processing)
         assert response is not None
-        assert len(response.polygons) == len(request.travel_cost.cutoffs)
+        assert len(response.polygons) == len(request.cutoffs)
         assert response.metadata.get("total_locations", 0) > 0
 
-        # Validate each polygon geometry (typical validation work)
+        # Validate each polygon structure (typical validation work)
         for polygon in response.polygons:
-            assert polygon.geometry is not None
-            assert polygon.geometry["type"] == "Polygon"
-            assert "coordinates" in polygon.geometry
-            if polygon.geometry["coordinates"]:
-                coords = polygon.geometry["coordinates"][0]
-                assert len(coords) >= 4  # Valid polygon
-                assert coords[0] == coords[-1]  # Closed polygon
+            assert hasattr(polygon, "travel_time"), "Polygon should have travel_time"
+            assert polygon.travel_time > 0, "Travel time should be positive"
+            assert hasattr(polygon, "points"), "Polygon should have points"
+            assert len(polygon.points) > 0, "Polygon should have coordinate points"
+            # Geometry is optional, may be None
 
         metrics.record_memory("post_processing_end")
         metrics.end_timing("post_processing")
@@ -189,6 +185,7 @@ async def test_motis_one_to_all_performance_benchmark():
         tracemalloc.stop()
 
 
+@pytest.mark.network
 async def test_motis_one_to_all_minimal_benchmark():
     """
     Minimal benchmark for quick performance checks.
@@ -200,22 +197,20 @@ async def test_motis_one_to_all_minimal_benchmark():
         # Simple single cutoff request for baseline performance
         metrics.start_timing("total")
 
-        adapter = create_motis_adapter(use_fixtures=False)
+        adapter = create_motis_adapter()
 
         request = TransitCatchmentAreaRequest(
-            starting_points=TransitCatchmentAreaStartingPoints(
-                lat=[52.5200], lon=[13.4050]
-            ),
+            starting_points=[{"lat": 52.5200, "lon": 13.4050}],
             transit_modes=[CatchmentAreaRoutingModePT.subway],
-            access_mode=AccessEgressMode.walk,
-            egress_mode=AccessEgressMode.walk,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
-                max_traveltime=15,
-                cutoffs=[15],
-            ),
+            cutoffs=[15],
+            access_settings=AccessEgressSettings.create_walk_settings(),
+            egress_settings=AccessEgressSettings.create_walk_settings(),
         )
 
-        response = await adapter.get_transit_catchment_area(request)
+        try:
+            response = await adapter._get_transit_catchment_area(request)
+        except Exception as e:
+            pytest.skip(f"MOTIS one-to-all service unavailable: {e}")
 
         metrics.end_timing("total")
         metrics.record_memory("final")
diff --git a/packages/python/goatlib/tests/benchmarks/test_network_performance.py b/packages/python/goatlib/tests/benchmarks/test_network_performance.py
index e6ec0c02d..7bc7cbc3e 100644
--- a/packages/python/goatlib/tests/benchmarks/test_network_performance.py
+++ b/packages/python/goatlib/tests/benchmarks/test_network_performance.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import psutil
+import pytest
 from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
 from goatlib.routing.schemas.base import Coordinates
 
@@ -398,3 +399,145 @@ def get_memory_info():
         logger.info(
             f"Scalability: {time_status} Time {time_scale_factor:.1f}x, {memory_status} Memory {memory_scale_factor:.1f}x, Edges {edge_scale_factor:.1f}x"
         )
+
+
+def test_benchmark_artificial_node_splitting():
+    """Benchmark artificial node splitting performance."""
+    test_file = Path(__file__).parent.parent / "data" / "network" / "network.parquet"
+
+    if not test_file.exists():
+        logger.error(f"Test file not found: {test_file}")
+        return
+    origin = Coordinates(lat=48.1351, lon=11.5820)
+    start_points = [
+        Coordinates(lat=origin.lat + i * 0.0001, lon=origin.lon + i * 0.0001)
+        for i in range(5)
+    ]
+
+    with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
+        # Load network once
+        subset_table = proc.load_network(center=origin, buffer_radius=400.0)
+        search_radius_m = 200.0
+        # Test artificial node creation multiple times
+        times = []
+        for i in range(10):
+            gc.collect()
+
+            t1 = time.perf_counter()
+
+            # Core artificial node creation
+            proc.create_artificial_nodes_for_points(
+                points=start_points,
+                search_radius_m=search_radius_m,
+                subset_table=subset_table,
+            )
+
+            t2 = time.perf_counter()
+            elapsed = (t2 - t1) * 1000
+            times.append(elapsed)
+
+        avg_time = sum(times) / len(times)
+        min_time = min(times)
+        max_time = max(times)
+
+        if avg_time < 5:
+            status = "✅"
+        elif avg_time < 10:
+            status = "✓"
+        else:
+            status = "⚠"
+            pytest.fail("Artificial node splitting too slow")
+
+        logger.info(
+            f"{status} Artificial node splitting: {avg_time:.2f}ms avg (range: {min_time:.2f}-{max_time:.2f}ms)"
+        )
+
+
+@pytest.mark.benchmark
+def test_benchmark_artificial_node_splitting_large():
+    """Test performance of create_artificial_nodes_for_points with larger datasets."""
+    test_file = Path(__file__).parent.parent / "data" / "network" / "network.parquet"
+
+    if not test_file.exists():
+        logger.error(f"Test file not found: {test_file}")
+        return
+
+    origin = Coordinates(lat=48.1351, lon=11.5820)
+
+    # Test with different sized datasets
+    test_sizes = [100, 200, 500]
+
+    for num_points in test_sizes:
+        logger.info(f"\n--- Testing with {num_points} points ---")
+
+        # Create random points around Munich
+        import random
+
+        random.seed(42)  # For reproducibility
+
+        start_points = []
+        for i in range(num_points):
+            # Generate points within reasonable distance from origin
+            lat_offset = random.uniform(-0.01, 0.01)  # ~1km radius
+            lon_offset = random.uniform(-0.01, 0.01)
+            start_points.append(
+                Coordinates(lat=origin.lat + lat_offset, lon=origin.lon + lon_offset)
+            )
+
+        with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
+            # Load network once
+            subset_table = proc.load_network(
+                center=origin, buffer_radius=2000.0
+            )  # Larger buffer for more points
+            search_radius_m = 200.0
+
+            # Measure performance over multiple runs
+            times = []
+            for _ in range(3):  # Fewer runs for large datasets
+                start_time = time.perf_counter()
+
+                result = proc.create_artificial_nodes_for_points(
+                    start_points, subset_table, search_radius_m=search_radius_m
+                )
+
+                end_time = time.perf_counter()
+
+                execution_time = (end_time - start_time) * 1000  # Convert to ms
+                times.append(execution_time)
+
+                # Verify result structure
+                assert result is not None
+                if isinstance(result, tuple):
+                    # Handle tuple return (file_path, node_ids)
+                    file_path, node_ids = result
+                    assert isinstance(file_path, str)
+                    assert file_path.endswith(".parquet")
+                    assert isinstance(node_ids, list)
+                else:
+                    # Handle string return
+                    assert isinstance(result, str)
+                    assert result.endswith(".parquet")
+
+            # Calculate statistics
+            avg_time = sum(times) / len(times)
+            min_time = min(times)
+            max_time = max(times)
+
+            # Adjust thresholds for larger datasets
+            if num_points <= 100:
+                threshold = 100  # 100ms for 100 points
+            elif num_points <= 200:
+                threshold = 300  # 300ms for 200 points
+            else:
+                threshold = 800  # 800ms for 500 points
+
+            if avg_time < threshold * 0.5:
+                status = "✅"
+            elif avg_time < threshold:
+                status = "✓"
+            else:
+                status = "⚠"
+
+            logger.info(
+                f"{status} Artificial node splitting ({num_points} points): {avg_time:.2f}ms avg (range: {min_time:.2f}-{max_time:.2f}ms, threshold: {threshold}ms)"
+            )
diff --git a/packages/python/goatlib/tests/integration/routing/network/test_catchment.py b/packages/python/goatlib/tests/integration/network/test_catchment.py
similarity index 79%
rename from packages/python/goatlib/tests/integration/routing/network/test_catchment.py
rename to packages/python/goatlib/tests/integration/network/test_catchment.py
index 1b11647e6..30bd2a986 100644
--- a/packages/python/goatlib/tests/integration/routing/network/test_catchment.py
+++ b/packages/python/goatlib/tests/integration/network/test_catchment.py
@@ -22,10 +22,15 @@ def test_catchment_workflow(network_file: Path):
     with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
         # Use the new optimized method that combines all preprocessing
         start_coords = Coordinates(lat=48.1351, lon=11.5820)
+
+        # Define cutoffs first to ensure network preparation covers the max cutoff
+        cutoffs_minutes = [10, 20, 30]
+        max_cutoff = max(cutoffs_minutes)
+
         parquet_path, start_node_id = proc.prepare_routing_network(
             start_point=start_coords,
             buffer_radius=1000.0,
-            travel_time_minutes=15.0,
+            travel_time_minutes=max_cutoff,  # Use max cutoff for network preparation
             speed_kmh=5.0,
         )
 
@@ -33,7 +38,7 @@ def test_catchment_workflow(network_file: Path):
         network = routing.load_network(parquet_path)
 
         # Calculate isochrones for the requested cutoffs (convert minutes to seconds)
-        cutoffs_seconds = [c * 60 for c in [10, 20, 30]]
+        cutoffs_seconds = [c * 60 for c in cutoffs_minutes]
         results = network.calculate_isochrone_multiple_times(
             start_node=start_node_id, time_thresholds=cutoffs_seconds
         )
@@ -42,7 +47,7 @@ def test_catchment_workflow(network_file: Path):
         for i, result in enumerate(results):
             assert result.reachable_nodes > 0
             logger.info(
-                f"Cutoff {[10, 20, 30][i]} min: {result.reachable_nodes} reachable nodes"
+                f"Cutoff {cutoffs_minutes[i]} min: {result.reachable_nodes} reachable nodes"
             )
 
 
@@ -135,7 +140,6 @@ def test_optimized_catchment_benchmark(network_file: Path):
         )
 
     # Summary analysis
-    logger.info("\n=== BENCHMARK SUMMARY ===")
     best_prep = min(r["prep_time"] for r in results)
     best_total = min(r["total_time"] for r in results)
 
@@ -156,8 +160,6 @@ def test_split_edge_accuracy_benchmark(network_file: Path):
     """
     Test the accuracy improvements of the optimized routing network preparation.
     """
-    logger.info("=== OPTIMIZED ROUTING NETWORK ACCURACY BENCHMARK ===")
-
     with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
         start_coords = Coordinates(lat=48.1351, lon=11.5820)
 
@@ -191,9 +193,6 @@ def test_split_edge_accuracy_benchmark(network_file: Path):
         """).fetchone()
 
         edge_count = network_info[0]
-        unique_nodes = len(
-            set([network_info[1], network_info[2]])
-        )  # Approximate unique nodes
         avg_length = network_info[3]
 
         logger.info(f"  Network edges: {edge_count}")
@@ -223,3 +222,45 @@ def test_split_edge_accuracy_benchmark(network_file: Path):
         ), f"Preparation took {prep_time:.1f}ms, should be under 150ms"
 
         logger.info("✓ Optimized routing network accuracy benchmark PASSED")
+
+
+# add a test to try calculate_multiple_isochrones on the rust_network_analysis module
+def test_rust_network_multiple_isochrones(network_file: Path):
+    """
+    Test the Rust network analysis library's ability to calculate multiple isochrones.
+    """
+
+    # Use InMemoryNetworkProcessor to prepare a properly formatted network for Rust
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        start_coords = Coordinates(lat=48.1351, lon=11.5820)
+
+        # Prepare the network in the format expected by the Rust library
+        parquet_path, start_node_id = proc.prepare_routing_network(
+            start_point=start_coords,
+            buffer_radius=1000.0,
+            travel_time_minutes=20.0,
+            speed_kmh=5.0,
+        )
+
+        # Load the network using the Rust library
+        network = routing.load_network(parquet_path)
+
+    # Define multiple cutoffs in seconds
+    cutoffs_seconds = [300, 600, 900]  # 5min, 10min, 15min
+
+    # Calculate multiple isochrones
+    results = network.calculate_isochrone_multiple_times(
+        start_node=start_node_id, time_thresholds=cutoffs_seconds
+    )
+
+    assert len(results) == len(cutoffs_seconds), "Should return results for all cutoffs"
+
+    for i, result in enumerate(results):
+        assert (
+            result.reachable_nodes > 0
+        ), f"Isochrone for cutoff {cutoffs_seconds[i]}s should have reachable nodes"
+        logger.info(
+            f"Cutoff {cutoffs_seconds[i]//60} min: {result.reachable_nodes} reachable nodes"
+        )
+
+    logger.info("✓ Rust network multiple isochrones test PASSED")
diff --git a/packages/python/goatlib/tests/integration/network/test_rust_network_analysis.py b/packages/python/goatlib/tests/integration/network/test_rust_network_analysis.py
new file mode 100644
index 000000000..7a373413f
--- /dev/null
+++ b/packages/python/goatlib/tests/integration/network/test_rust_network_analysis.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+import os
+import time
+from pathlib import Path
+
+import fast_routing_py as routing
+
+
+def test_analyze_rust_network_loading():
+    """Detailed analysis of how the Rust library loads and processes networks"""
+
+    # Use an existing network file from the recent run
+    temp_dirs = [d for d in Path("/tmp").glob("routing_*") if d.is_dir()]
+    network_files = []
+
+    for temp_dir in temp_dirs:
+        for parquet_file in temp_dir.glob("*.parquet"):
+            network_files.append(parquet_file)
+
+    if not network_files:
+        print("No network files found. Please run the PT workflow first.")
+        return
+
+    # Use the most recent network file
+    parquet_path = max(network_files, key=lambda p: p.stat().st_mtime)
+    print(f"Using network file: {parquet_path}")
+
+    # Check file size
+    file_size = os.path.getsize(parquet_path) / (1024 * 1024)
+    print(f"Parquet file size: {file_size:.2f}MB")
+
+    # Now test Rust loading with detailed timing
+    print("\nTesting Rust network loading...")
+
+    # Test 1: Basic loading - repeat multiple times for accuracy
+    load_times = []
+    for i in range(3):
+        start_time = time.time()
+        network = routing.load_network(str(parquet_path))
+        rust_load_time = time.time() - start_time
+        load_times.append(rust_load_time)
+        print(f"  Loading attempt {i+1}: {rust_load_time:.3f}s")
+
+    avg_load_time = sum(load_times) / len(load_times)
+    print(f"Average Rust network loading: {avg_load_time:.3f}s")
+
+    # Test 2: Get network info
+    start_time = time.time()
+    try:
+        info = network.get_network_info()
+        info_time = time.time() - start_time
+        print(f"Network info retrieval: {info_time:.3f}s")
+        print(f"Network info: {info}")
+    except Exception as e:
+        print(f"Error getting network info: {e}")
+
+    # Test 3: Get all node IDs
+    start_time = time.time()
+    try:
+        node_ids = network.get_all_node_ids()
+        node_ids_time = time.time() - start_time
+        print(f"Node IDs retrieval: {node_ids_time:.3f}s")
+        print(f"Total nodes from Rust: {len(node_ids)}")
+
+        # Sample some node IDs
+        if len(node_ids) > 0:
+            print(f"Node ID range: {min(node_ids)} to {max(node_ids)}")
+            print(
+                f"Sample node IDs: {node_ids[:10] if len(node_ids) > 10 else node_ids}"
+            )
+    except Exception as e:
+        print(f"Error getting node IDs: {e}")
+        return
+
+    # Test 4: Single isochrone calculation timing
+    if len(node_ids) > 0:
+        test_node = node_ids[len(node_ids) // 2]  # Use middle node
+
+        # Test different time limits
+        time_limits = [300, 600, 900]  # 5, 10, 15 minutes
+        for limit in time_limits:
+            start_time = time.time()
+            try:
+                result = network.calculate_isochrone(test_node, limit)
+                calc_time = time.time() - start_time
+                print(
+                    f"Single isochrone ({limit//60}min): {calc_time:.3f}s, reached {len(result.nodes)} nodes"
+                )
+            except Exception as e:
+                print(f"Error calculating single isochrone ({limit//60}min): {e}")
+
+    # Test 5: Multiple isochrones calculation with different batch sizes
+    if len(node_ids) > 10:
+        batch_sizes = [1, 5, 10, 20]
+        time_limit = 600  # 10 minutes
+
+        for batch_size in batch_sizes:
+            if batch_size > len(node_ids):
+                continue
+
+            test_nodes = node_ids[:batch_size]
+            start_time = time.time()
+            try:
+                results = network.calculate_multiple_isochrones(test_nodes, time_limit)
+                calc_time = time.time() - start_time
+                avg_nodes = sum(len(r.nodes) for r in results) / len(results)
+                time_per_node = calc_time / batch_size
+                print(
+                    f"Multiple isochrones (batch={batch_size}): {calc_time:.3f}s total, {time_per_node:.3f}s per node, avg {avg_nodes:.0f} reached"
+                )
+            except Exception as e:
+                print(
+                    f"Error calculating multiple isochrones (batch={batch_size}): {e}"
+                )
+
+    print("\nPerformance Summary:")
+    print(f"  Average Rust loading: {avg_load_time:.3f}s")
+    print(f"  File size: {file_size:.2f}MB")
+    print(f"  Load time per MB: {avg_load_time / file_size:.3f} s/MB")
+    print(f"  Total nodes: {len(node_ids)}")
+
+    # Calculate throughput
+    if len(node_ids) > 0:
+        print(
+            f"  Load time per 1000 nodes: {avg_load_time / len(node_ids) * 1000:.3f} s/1000nodes"
+        )
diff --git a/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_errors.py b/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_errors.py
index 4674decfa..6de8e80df 100644
--- a/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_errors.py
+++ b/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_errors.py
@@ -10,9 +10,7 @@
 async def test_invalid_api_url_handling() -> None:
     """Test handling of invalid API URLs."""
     # Create a separate adapter with invalid URL for this test
-    adapter = create_motis_adapter(
-        use_fixtures=False, base_url="https://nonexistent-api.example.com"
-    )
+    adapter = create_motis_adapter(base_url="https://nonexistent-api.example.com")
 
     request = ABRoutingRequest(
         origin=Coordinates(lat=52.5200, lon=13.4050),
diff --git a/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_fixture.py b/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_fixture.py
deleted file mode 100644
index f425a7f82..000000000
--- a/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_fixture.py
+++ /dev/null
@@ -1,142 +0,0 @@
-import pytest
-from goatlib.routing.adapters.motis import MotisPlanApiAdapter, create_motis_adapter
-from goatlib.routing.errors import RoutingError
-from goatlib.routing.schemas.ab_routing import ABRoute, ABRoutingRequest
-from goatlib.routing.schemas.base import Coordinates, Mode
-
-
-# --- Helper Functions ---
-def validate_route_data(routes: list[ABRoute]) -> None:
-    """Helper function to validate route data structure and content."""
-    for route in routes:
-        # Route validation
-        assert route.duration > 0
-        assert route.distance >= 0
-        assert route.departure_time is not None
-        assert len(route.legs) > 0
-
-        # Leg validation
-        for leg in route.legs:
-            assert (
-                leg.duration > 0
-            ), f"Leg {leg.leg_id} has invalid duration: {leg.duration}"
-            assert (
-                leg.departure_time < leg.arrival_time
-            ), f"Leg {leg.leg_id} has invalid timing"
-            assert leg.origin is not None
-            assert leg.destination is not None
-
-
-# --- Fixtures ---
-
-
-@pytest.fixture
-def test_request() -> ABRoutingRequest:
-    """Standard, module-scoped test request for fixture testing."""
-    return ABRoutingRequest(
-        origin=Coordinates(lat=48.1351, lon=11.5820),  # Munich
-        destination=Coordinates(lat=48.7758, lon=9.1829),  # Stuttgart
-        modes=[Mode.transit, Mode.walk],
-        max_results=3,
-    )
-
-
-# --- Test Cases ---
-
-
-async def test_fixture_routing_basic_success(
-    motis_adapter_fixture: MotisPlanApiAdapter, test_request: ABRoutingRequest
-) -> None:
-    """Test basic fixture routing functionality returns valid routes."""
-    response = await motis_adapter_fixture.route(test_request)
-    routes = response.routes
-
-    assert routes, "Should return routes from fixture data"
-    validate_route_data(routes)
-
-
-def test_fixture_adapter_creation_with_valid_path(motis_fixtures_dir: str) -> None:
-    """Test creating fixture adapter with valid path."""
-    adapter = create_motis_adapter(use_fixtures=True, fixture_path=motis_fixtures_dir)
-    assert isinstance(adapter, MotisPlanApiAdapter)
-    assert adapter.motis_client.use_fixtures is True
-
-
-# CHANGE 4: Combined realism checks into a single, more comprehensive test.
-async def test_fixture_route_realism_validation(
-    motis_adapter_fixture: MotisPlanApiAdapter, test_request: ABRoutingRequest
-) -> None:
-    """Test that fixture data calculations (distance, speed) are reasonable."""
-    response = await motis_adapter_fixture.route(test_request)
-    routes = response.routes
-    assert routes, "Cannot perform validation on an empty route list."
-
-    for route in routes:
-        # Route distance might be None if no walking legs have distance data (MOTIS behavior)
-        if route.distance is not None:
-            assert (
-                100 <= route.distance <= 1_000_000
-            ), f"Route distance {route.distance}m is unrealistic"
-        assert (
-            120 <= route.duration <= 43_200
-        ), f"Route duration {route.duration}s is unrealistic"
-
-        for leg in route.legs:
-            # Speed checks are only meaningful if both duration and distance are available
-            if leg.duration > 0 and leg.distance is not None and leg.distance > 0:
-                speed_kmh = (leg.distance / 1000) / (leg.duration / 3600)
-                # Basic sanity check: speed should be between 1 and 300 km/h
-                assert (
-                    1 <= speed_kmh <= 300
-                ), f"Leg {leg.leg_id} ({leg.mode.value}) has unrealistic speed: {speed_kmh:.1f} km/h."
-            # For transit legs without distance data (common with MOTIS), we can't validate speed
-            # This is expected behavior since MOTIS doesn't always provide route distances for transit
-
-
-# --- Error Handling Tests ---
-
-
-async def test_empty_fixture_directory(tmp_path: pytest.TempPathFactory) -> None:
-    """Test handling of empty fixture directories."""
-    empty_dir = tmp_path / "empty"
-    empty_dir.mkdir()
-
-    adapter = create_motis_adapter(use_fixtures=True, fixture_path=empty_dir)
-    request = ABRoutingRequest(
-        origin=Coordinates(lat=48.1, lon=11.5),
-        destination=Coordinates(lat=48.2, lon=11.6),
-        modes=[Mode.walk],
-        max_results=1,
-    )
-
-    try:
-        with pytest.raises(RoutingError):
-            await adapter.route(request)
-    finally:
-        # For fixture-based adapters, close might not be needed, but let's be safe
-        if hasattr(adapter.motis_client, "close"):
-            await adapter.motis_client.close()
-
-
-async def test_corrupted_fixture_file_handling(
-    tmp_path: pytest.TempPathFactory,
-) -> None:
-    """Test handling of corrupted fixture files."""
-    # Create a corrupted JSON file
-    corrupted_file = tmp_path / "test_motis_routes_corrupted.json"
-    corrupted_file.write_text("{ invalid json content")
-
-    adapter = create_motis_adapter(use_fixtures=True, fixture_path=tmp_path)
-    request = ABRoutingRequest(
-        origin=Coordinates(lat=48.1, lon=11.5),
-        destination=Coordinates(lat=48.2, lon=11.6),
-        modes=[Mode.walk],
-        max_results=1,
-    )
-
-    try:
-        with pytest.raises(RoutingError):
-            await adapter.route(request)
-    finally:
-        if hasattr(adapter.motis_client, "close"):
-            await adapter.motis_client.close()
diff --git a/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_online.py b/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_online.py
index d1e9e7506..8171f5398 100644
--- a/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_online.py
+++ b/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_online.py
@@ -40,7 +40,6 @@ def test_request() -> ABRoutingRequest:
 # --- Test Cases ---
 
 
-@pytest.mark.slow
 @pytest.mark.network
 async def test_fixture_routing_basic_success(
     motis_adapter_online: MotisPlanApiAdapter, test_request: ABRoutingRequest
@@ -53,7 +52,6 @@ async def test_fixture_routing_basic_success(
     validate_route_data(routes)
 
 
-@pytest.mark.slow
 @pytest.mark.network
 async def test_fixture_different_requests_return_data(
     motis_adapter_online: MotisPlanApiAdapter,
@@ -79,7 +77,6 @@ async def test_fixture_different_requests_return_data(
     assert response2.routes, "Second request should yield routes"
 
 
-@pytest.mark.slow
 @pytest.mark.network
 async def test_fixture_max_results_enforcement(
     motis_adapter_online: MotisPlanApiAdapter,
@@ -98,7 +95,6 @@ async def test_fixture_max_results_enforcement(
     ), f"Should return at most 5 routes, got {len(response.routes)}"
 
 
-@pytest.mark.slow
 @pytest.mark.network
 async def test_fixture_distance_calculation_and_speed_realism(
     motis_adapter_online: MotisPlanApiAdapter, test_request: ABRoutingRequest
diff --git a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_adapter_one_to_all.py b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_adapter_one_to_all.py
index 0764089f0..05c20b85d 100644
--- a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_adapter_one_to_all.py
+++ b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_adapter_one_to_all.py
@@ -1,99 +1,142 @@
+import logging
+
 import pytest
+from goatlib.routing.adapters.motis.motis_adapter import create_motis_adapter
 from goatlib.routing.schemas.base import (
     AccessEgressMode,
     CatchmentAreaRoutingModePT,
+    Coordinates,
 )
 from goatlib.routing.schemas.catchment_area_transit import (
+    AccessEgressSettings,
     TransitCatchmentAreaRequest,
-    TransitCatchmentAreaStartingPoints,
-    TransitCatchmentAreaTravelTimeCost,
 )
 
-
-@pytest.mark.slow
-@pytest.mark.network
-class TestMotisAdapterOneToAll:
-    """Test class for MOTIS one-to-all functionality."""
-
-    async def test_basic_one_to_all_success(self, motis_adapter_online, berlin_request):
-        """Test basic one-to-all functionality returns valid catchment areas."""
-        response = await motis_adapter_online.get_transit_catchment_area(berlin_request)
-
-        # Basic structure checks
-        assert response is not None
-        assert len(response.polygons) == len(berlin_request.travel_cost.cutoffs)
-        assert response.metadata.get("total_locations", 0) > 0
-        assert response.metadata.get("source") == "motis_one_to_all"
-
-        # Check each polygon
-        for polygon in response.polygons:
-            assert polygon.travel_time in berlin_request.travel_cost.cutoffs
+logger = logging.getLogger(__name__)
+
+
+async def test_basic_one_to_all_success():
+    """Test basic one-to-all functionality returns valid catchment areas."""
+    adapter = create_motis_adapter()
+
+    berlin_request = TransitCatchmentAreaRequest(
+        starting_points=[Coordinates(lat=52.520008, lon=13.404954)],  # Berlin center
+        cutoffs=[15, 30],
+        transit_modes=[CatchmentAreaRoutingModePT.bus, CatchmentAreaRoutingModePT.tram],
+        access_settings=AccessEgressSettings(
+            mode=AccessEgressMode.walk, max_time=10, speed=5.0
+        ),
+        egress_settings=AccessEgressSettings(
+            mode=AccessEgressMode.walk, max_time=10, speed=5.0
+        ),
+    )
+
+    async with adapter.motis_client:
+        response = await adapter._get_transit_catchment_area(berlin_request)
+
+    # Basic structure checks
+    assert response is not None
+    assert len(response.polygons) == len(berlin_request.cutoffs)
+    assert response.metadata.get("total_locations", 0) > 0
+    assert response.metadata.get("source") == "motis_one_to_all"
+
+    # Check each polygon
+    for polygon in response.polygons:
+        assert polygon.travel_time in berlin_request.cutoffs
+        assert hasattr(polygon, "points")
+        assert isinstance(polygon.points, list)
+
+        # Geometry may be None initially, can be generated from points
+        if polygon.geometry is not None:
             assert polygon.geometry["type"] == "Polygon"
             assert "coordinates" in polygon.geometry
-
-    async def test_multiple_cutoffs(self, motis_adapter_online, munich_request):
-        """Test that multiple travel time cutoffs generate correct polygons."""
-        response = await motis_adapter_online.get_transit_catchment_area(munich_request)
-
-        assert len(response.polygons) == len(munich_request.travel_cost.cutoffs)
-
-        # Polygons should be ordered by travel time
-        travel_times = [p.travel_time for p in response.polygons]
-        assert sorted(travel_times) == sorted(munich_request.travel_cost.cutoffs)
-
-    async def test_different_transit_modes(self, motis_adapter_online):
-        """Test different combinations of transit modes."""
-        starting_points = TransitCatchmentAreaStartingPoints(
-            lat=[52.5200], lon=[13.4050]
-        )
-        rail_only_request = TransitCatchmentAreaRequest(
-            starting_points=starting_points,
-            transit_modes=[CatchmentAreaRoutingModePT.rail],
-            access_mode=AccessEgressMode.walk,
-            egress_mode=AccessEgressMode.walk,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
-                max_traveltime=20, cutoffs=[20]
-            ),
-        )
-
-        response = await motis_adapter_online.get_transit_catchment_area(
-            rail_only_request
-        )
-
-        assert len(response.polygons) == 1
-        assert response.polygons[0].travel_time == 20
-
-    async def test_single_cutoff(self, motis_adapter_online):
-        """Test with a single travel time cutoff."""
-        starting_points = TransitCatchmentAreaStartingPoints(
-            lat=[48.1351],
-            lon=[11.5820],  # Munich
-        )
-        single_cutoff_request = TransitCatchmentAreaRequest(
-            starting_points=starting_points,
-            transit_modes=[
-                CatchmentAreaRoutingModePT.subway,
-                CatchmentAreaRoutingModePT.tram,
-            ],
-            access_mode=AccessEgressMode.walk,
-            egress_mode=AccessEgressMode.walk,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
-                max_traveltime=20, cutoffs=[20]
-            ),
-        )
-
-        response = await motis_adapter_online.get_transit_catchment_area(
-            single_cutoff_request
-        )
-
-        assert len(response.polygons) == 1
-        assert response.polygons[0].travel_time == 20
-
-    async def test_geometry_structure(self, motis_adapter_online, berlin_request):
-        """Test that returned geometry has correct GeoJSON structure."""
-        response = await motis_adapter_online.get_transit_catchment_area(berlin_request)
-
-        for polygon in response.polygons:
+        else:
+            # Test that geometry can be generated from points
+            polygon.set_geometry_from_points()
+            if polygon.points:  # Only check if there are points
+                assert polygon.geometry["type"] == "Polygon"
+                assert "coordinates" in polygon.geometry
+
+
+async def test_multiple_cutoffs():
+    """Test that multiple travel time cutoffs generate correct polygons."""
+    adapter = create_motis_adapter()
+
+    munich_request = TransitCatchmentAreaRequest(
+        starting_points=[Coordinates(lat=48.137154, lon=11.576124)],  # Munich center
+        cutoffs=[10, 20, 30],
+        transit_modes=[CatchmentAreaRoutingModePT.bus, CatchmentAreaRoutingModePT.tram],
+        access_settings=AccessEgressSettings(
+            mode=AccessEgressMode.walk, max_time=10, speed=5.0
+        ),
+        egress_settings=AccessEgressSettings(
+            mode=AccessEgressMode.walk, max_time=10, speed=5.0
+        ),
+    )
+
+    async with adapter.motis_client:
+        response = await adapter._get_transit_catchment_area(munich_request)
+
+    assert len(response.polygons) == len(munich_request.cutoffs)
+
+    # Polygons should be ordered by travel time
+    travel_times = [p.travel_time for p in response.polygons]
+    assert sorted(travel_times) == sorted(munich_request.cutoffs)
+
+
+async def test_different_transit_modes(motis_adapter_online):
+    """Test different combinations of transit modes."""
+    rail_only_request = TransitCatchmentAreaRequest(
+        starting_points=[{"lat": 52.5200, "lon": 13.4050}],
+        transit_modes=[CatchmentAreaRoutingModePT.rail],
+        cutoffs=[20],
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
+    )
+
+    response = await motis_adapter_online._get_transit_catchment_area(rail_only_request)
+
+    assert len(response.polygons) == 1
+
+
+async def test_single_cutoff(motis_adapter_online):
+    """Test with a single travel time cutoff."""
+    single_cutoff_request = TransitCatchmentAreaRequest(
+        starting_points=[
+            {"lat": 48.1351, "lon": 11.5820}  # Munich
+        ],
+        transit_modes=[
+            CatchmentAreaRoutingModePT.subway,
+            CatchmentAreaRoutingModePT.tram,
+        ],
+        cutoffs=[20],
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
+    )
+
+    response = await motis_adapter_online._get_transit_catchment_area(
+        single_cutoff_request
+    )
+
+    assert len(response.polygons) == 1
+    assert response.polygons[0].travel_time == 20
+
+
+async def test_geometry_structure(motis_adapter_online, berlin_request):
+    """Test that returned geometry has correct GeoJSON structure."""
+    response = await motis_adapter_online._get_transit_catchment_area(berlin_request)
+
+    for polygon in response.polygons:
+        # Check that polygon has points field
+        assert hasattr(polygon, "points")
+        assert isinstance(polygon.points, list)
+
+        # If geometry is None, generate it from points for testing
+        if polygon.geometry is None:
+            polygon.set_geometry_from_points()
+
+        # Now test the geometry structure (if points exist)
+        if polygon.points and polygon.geometry:
             assert polygon.geometry["type"] == "Polygon"
             assert "coordinates" in polygon.geometry
             if polygon.geometry["coordinates"]:
@@ -102,57 +145,53 @@ async def test_geometry_structure(self, motis_adapter_online, berlin_request):
                 assert len(coord_ring[0]) == 2
                 assert coord_ring[0] == coord_ring[-1]
 
-    @pytest.mark.skip(reason="MOTIS bicycle access causes 500 error on public instance")
-    async def test_bike_access_egress(self, motis_adapter_online):
-        """Test catchment area with bicycle access and egress modes."""
-        starting_points = TransitCatchmentAreaStartingPoints(
-            lat=[52.5200], lon=[13.4050]
-        )
-        bike_request = TransitCatchmentAreaRequest(
-            starting_points=starting_points,
-            transit_modes=[
-                CatchmentAreaRoutingModePT.bus,
-                CatchmentAreaRoutingModePT.tram,
-            ],
-            access_mode=AccessEgressMode.bicycle,
-            egress_mode=AccessEgressMode.bicycle,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
-                max_traveltime=25, cutoffs=[25]
-            ),
-        )
-
-        response = await motis_adapter_online.get_transit_catchment_area(bike_request)
-
-        assert len(response.polygons) == 1
-        assert response.polygons[0].travel_time == 25
-
-    async def test_invalid_coordinates_handling(self, motis_adapter_online):
-        """Test handling of coordinates outside valid geographic range."""
-        # MOTIS accepts invalid coordinates and returns empty results
-        starting_points = TransitCatchmentAreaStartingPoints(
-            lat=[91.0],
-            lon=[181.0],  # Invalid coordinates
-        )
-        invalid_request = TransitCatchmentAreaRequest(
-            starting_points=starting_points,
-            transit_modes=[CatchmentAreaRoutingModePT.bus],
-            access_mode=AccessEgressMode.walk,
-            egress_mode=AccessEgressMode.walk,
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
-                max_traveltime=15, cutoffs=[15]
-            ),
-        )
-
-        response = await motis_adapter_online.get_transit_catchment_area(
-            invalid_request
-        )
-
-        # Should return valid structure but with no locations
-        assert response.metadata.get("total_locations", 0) == 0
-        assert len(response.polygons) == 0
-
-
-@pytest.mark.slow
+
+async def test_bike_access_egress(motis_adapter_online):
+    """Test catchment area with bicycle access and egress modes."""
+    bike_request = TransitCatchmentAreaRequest(
+        starting_points=[{"lat": 52.5200, "lon": 13.4050}],
+        transit_modes=[
+            CatchmentAreaRoutingModePT.bus,
+            CatchmentAreaRoutingModePT.tram,
+        ],
+        cutoffs=[25],
+        access_settings=AccessEgressSettings(
+            mode=AccessEgressMode.bicycle, max_time=15, speed=15.0
+        ),
+        egress_settings=AccessEgressSettings(
+            mode=AccessEgressMode.bicycle, max_time=15, speed=15.0
+        ),
+    )
+
+    response = await motis_adapter_online._get_transit_catchment_area(bike_request)
+
+    assert len(response.polygons) == 1
+    assert response.polygons[0].travel_time == 25
+    assert bike_request.access_settings.mode == AccessEgressMode.bicycle
+    assert bike_request.egress_settings.mode == AccessEgressMode.bicycle
+
+
+async def test_invalid_coordinates_handling(motis_adapter_online):
+    """Test handling of coordinates in remote areas with no transit coverage."""
+    # Use coordinates in the middle of the Pacific Ocean where MOTIS has no data
+    remote_request = TransitCatchmentAreaRequest(
+        starting_points=[
+            {"lat": 0.0, "lon": -160.0}  # Middle of Pacific Ocean
+        ],
+        transit_modes=[CatchmentAreaRoutingModePT.bus],
+        cutoffs=[15],
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
+    )
+
+    response = await motis_adapter_online._get_transit_catchment_area(remote_request)
+
+    # Should return valid structure but likely with no or minimal locations
+    assert response is not None
+    assert len(response.polygons) <= len(remote_request.cutoffs)
+    assert response.metadata.get("total_locations", 0) == 0
+
+
 @pytest.mark.network
 async def test_motis_one_to_all_integration_minimal(
     simple_berlin_request: TransitCatchmentAreaRequest,
@@ -160,11 +199,11 @@ async def test_motis_one_to_all_integration_minimal(
     """Minimal integration test that can run independently."""
     from goatlib.routing.adapters.motis import create_motis_adapter
 
-    adapter = create_motis_adapter(use_fixtures=False)
+    adapter = create_motis_adapter()
 
     try:
-        response = await adapter.get_transit_catchment_area(simple_berlin_request)
-        assert len(response.polygons) == len(simple_berlin_request.travel_cost.cutoffs)
+        response = await adapter._get_transit_catchment_area(simple_berlin_request)
+        assert len(response.polygons) == len(simple_berlin_request.cutoffs)
         assert response.metadata.get("source") == "motis_one_to_all"
 
     finally:
diff --git a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_buffered_station.py b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_buffered_station.py
new file mode 100644
index 000000000..8689a98a3
--- /dev/null
+++ b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_buffered_station.py
@@ -0,0 +1,323 @@
+import json
+import logging
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+import geopandas as gpd
+import pytest
+from goatlib.analysis.schemas.vector import BufferParams
+from goatlib.analysis.vector.buffer import BufferTool
+from goatlib.routing.adapters.motis.motis_converters import (
+    extract_bus_stations_for_buffering,
+    translate_to_motis_one_to_all_request,
+)
+from goatlib.routing.schemas.catchment_area_transit import (
+    TransitCatchmentAreaRequest,
+)
+from shapely.geometry import Point
+
+logger = logging.getLogger(__name__)
+
+
+def create_pt_buffer_params(
+    reachable_locations: List[Dict[str, Any]],
+    config: Dict[str, Any],
+    work_dir: Path,
+) -> BufferParams:
+    """
+    Converts dictionary list to Parquet, then returns BufferParams.
+    """
+    # 1. Prepare Output Paths
+    input_path = work_dir / "motis_stations_input.parquet"
+    output_path = work_dir / "motis_stations_buffered.parquet"
+
+    # 2. Convert MOTIS list to GeoDataFrame
+    gdf_data = []
+    for station in reachable_locations:
+        coords = station["coordinates"]  # [lon, lat]
+        gdf_data.append(
+            {
+                "name": station.get("name", "Unknown"),
+                "duration_minutes": station.get("duration_minutes", 0),
+                "stop_id": station.get("stop_id", ""),
+                "geometry": Point(coords[0], coords[1]),  # lon, lat
+            }
+        )
+
+    gdf = gpd.GeoDataFrame(gdf_data, crs="EPSG:4326")
+    gdf.to_parquet(input_path)
+
+    # 3. Create BufferParams with full configuration
+    return BufferParams(
+        input_path=str(input_path),
+        output_path=str(output_path),
+        distances=config["distances"],  # e.g. [200, 400, 600]
+        units="meters",
+        dissolve=True,  # Merge overlapping circles into one shape
+        num_triangles=8,
+        cap_style="CAP_ROUND",
+        join_style="JOIN_ROUND",
+        output_crs="EPSG:4326",
+        output_name="pt_access_buffers",
+    )
+
+
+@pytest.fixture
+def pt_buffer_config() -> Dict[str, Any]:
+    """Single configuration for Public Transport Station Access."""
+    return {
+        "name": "pt_station_walk",
+        "title": "🚌 Public Transport Access",
+        "distances": [200, 400, 600],  # Walking distance from stations
+        "description": "Buffer zones around reachable stations",
+        "use_case": "Transit Coverage Analysis",
+    }
+
+
+@pytest.fixture
+def buffered_stations_dir(tmp_path):
+    """Temporary directory for buffered station outputs."""
+    return tmp_path / "buffered_stations"
+
+
+@pytest.mark.asyncio
+@pytest.mark.network  # Mark as requiring network access
+async def test_simple_motis_buffer_pipeline(
+    motis_adapter_online,
+    munich_request: TransitCatchmentAreaRequest,
+    pt_buffer_config: Dict[str, Any],
+    buffered_stations_dir: Path,
+) -> None:
+    """
+    Simple test: 1. Fetch MOTIS stations, 2. Buffer them, 3. Save results.
+    """
+    buffered_stations_dir.mkdir(exist_ok=True)
+
+    try:
+        # Step 1: Get MOTIS data
+        motis_req = translate_to_motis_one_to_all_request(munich_request)
+        logger.info("🚀 Requesting MOTIS One-to-All...")
+        motis_response = await motis_adapter_online.motis_client.one_to_all(motis_req)
+
+        # Step 2: Extract station data
+        bus_stations = extract_bus_stations_for_buffering(motis_response)
+        if len(bus_stations) == 0:
+            pytest.skip("No reachable stations found for test location")
+
+        logger.info(f"Found {len(bus_stations)} reachable stations.")
+
+        # Step 3: Create buffer parameters
+        params = create_pt_buffer_params(
+            reachable_locations=bus_stations,
+            config=pt_buffer_config,
+            work_dir=buffered_stations_dir,
+        )
+
+        # Step 4: Run buffering
+        logger.info("⚙️ Running BufferTool...")
+        tool = BufferTool()
+        results = tool.run(params)
+
+        # Step 5: Verify results
+        output_path = Path(params.output_path)
+        assert output_path.exists()
+        buffered_gdf = gpd.read_parquet(output_path)
+        assert len(buffered_gdf) > 0
+        assert "geometry" in buffered_gdf.columns
+
+    except Exception as e:
+        logger.warning(f"Test failed: {e}")
+        pytest.skip(f"MOTIS API or buffer processing unavailable: {e}")
+
+
+@pytest.mark.asyncio
+async def test_motis_performance_simple(
+    motis_adapter_online,
+    munich_request: TransitCatchmentAreaRequest,
+) -> None:
+    """Simple performance test for MOTIS API."""
+
+    logger.info("=== Simple MOTIS Performance Test ===")
+
+    try:
+        # Time the API call
+        start_time = time.perf_counter()
+
+        motis_req = translate_to_motis_one_to_all_request(munich_request)
+        motis_response = await motis_adapter_online.motis_client.one_to_all(motis_req)
+
+        api_time = (time.perf_counter() - start_time) * 1000
+
+        # Extract and analyze results
+        bus_stations = extract_bus_stations_for_buffering(motis_response)
+
+        logger.info(f"API call time: {api_time:.1f}ms")
+        logger.info(f"Stations found: {len(bus_stations)}")
+
+        # Basic assertions
+        assert api_time < 5000  # Less than 5 seconds
+        assert (
+            len(bus_stations) >= 0
+        )  # At least some stations (or none if location has no transit)
+
+        logger.info("✅ Performance test completed successfully")
+
+    except Exception as e:
+        logger.warning(f"Performance test failed: {e}")
+        pytest.skip(f"MOTIS API unavailable: {e}")
+
+
+@pytest.mark.asyncio
+async def test_pipeline_performance(
+    motis_adapter_online,
+    munich_request: TransitCatchmentAreaRequest,
+    buffered_stations_dir: Path,
+    pt_buffer_config: Dict[str, Any],
+) -> None:
+    """Performance timing test for MOTIS -> Buffer pipeline."""
+
+    buffered_stations_dir.mkdir(exist_ok=True)
+
+    # Setup timing stats
+    stats = {}
+    t_start = time.perf_counter()
+
+    # Phase 1: API Request
+    logger.info("⏱️ Phase 1: MOTIS API Request")
+    t_api = time.perf_counter()
+
+    try:
+        motis_req = translate_to_motis_one_to_all_request(munich_request)
+        motis_response = await motis_adapter_online.motis_client.one_to_all(motis_req)
+    except Exception as e:
+        pytest.skip(f"MOTIS API unavailable: {e}")
+
+    stats["api_latency_sec"] = round(time.perf_counter() - t_api, 4)
+
+    # Phase 2: Data Processing
+    logger.info("⏱️ Phase 2: Data Processing")
+    t_process = time.perf_counter()
+
+    bus_stations = extract_bus_stations_for_buffering(motis_response)
+    assert len(bus_stations) > 0, "No stations found for timing test"
+
+    stats["processing_sec"] = round(time.perf_counter() - t_process, 4)
+
+    # Phase 3: Buffer Creation
+    logger.info("⏱️ Phase 3: Buffer Creation")
+    t_buffer_setup = time.perf_counter()
+
+    params = create_pt_buffer_params(
+        reachable_locations=bus_stations,
+        config=pt_buffer_config,
+        work_dir=buffered_stations_dir,
+    )
+
+    stats["buffer_setup_sec"] = round(time.perf_counter() - t_buffer_setup, 4)
+
+    # BufferTool execution timing
+    t_buffer_run = time.perf_counter()
+    tool = BufferTool()
+    results = tool.run(params)
+    stats["buffer_run_sec"] = round(time.perf_counter() - t_buffer_run, 4)
+
+    # Calculate totals
+    stats["total_time_sec"] = round(time.perf_counter() - t_start, 4)
+    stats["stations_processed"] = len(bus_stations)
+
+    # Verify results
+    output_path = Path(params.output_path)
+    assert output_path.exists()
+    buffered_gdf = gpd.read_parquet(output_path)
+    assert len(buffered_gdf) > 0
+
+    # Performance analysis logging
+    logger.info("\\n=== PERFORMANCE ANALYSIS ===\\n")
+    logger.info(f"Total pipeline time: {stats['total_time_sec']:.3f}s")
+    logger.info(f"  - API request: {stats['api_latency_sec']:.3f}s")
+    logger.info(f"  - Data processing: {stats['processing_sec']:.3f}s")
+    logger.info(f"  - Buffer setup: {stats['buffer_setup_sec']:.3f}s")
+    logger.info(f"  - Buffer execution: {stats['buffer_run_sec']:.3f}s")
+    logger.info(f"Stations processed: {stats['stations_processed']}")
+    logger.info(f"Buffer zones created: {len(buffered_gdf)}")
+
+    # Performance assertions
+    assert stats["total_time_sec"] < 10.0  # Should complete in under 10 seconds
+    assert stats["api_latency_sec"] < 5.0  # API should respond in under 5 seconds
+
+
+@pytest.mark.asyncio
+async def test_detailed_motis_analysis(
+    motis_adapter_online,
+    munich_request: TransitCatchmentAreaRequest,
+) -> None:
+    """
+    Detailed analysis test to understand MOTIS API response structure.
+    Validates data quality and provides insights into station distribution.
+    """
+    logger.info("=== DETAILED MOTIS ANALYSIS ===")
+
+    try:
+        # Get MOTIS data
+        motis_req = translate_to_motis_one_to_all_request(munich_request)
+        motis_response = await motis_adapter_online.motis_client.one_to_all(motis_req)
+
+        # Extract and analyze stations
+        bus_stations = extract_bus_stations_for_buffering(motis_response)
+
+        if len(bus_stations) == 0:
+            pytest.skip("No stations found for analysis")
+
+        # Analyze station data structure
+        sample_station = bus_stations[0]
+        logger.info(f"Sample station structure: {json.dumps(sample_station, indent=2)}")
+
+        # Station distribution analysis
+        duration_ranges = {"0-15min": 0, "15-30min": 0, "30-45min": 0, "45min+": 0}
+        for station in bus_stations:
+            duration = station.get("duration_minutes", 0)
+            if duration <= 15:
+                duration_ranges["0-15min"] += 1
+            elif duration <= 30:
+                duration_ranges["15-30min"] += 1
+            elif duration <= 45:
+                duration_ranges["30-45min"] += 1
+            else:
+                duration_ranges["45min+"] += 1
+
+        # Data quality checks
+        stations_with_names = sum(
+            1 for s in bus_stations if s.get("name") and s["name"] != "Unknown"
+        )
+        stations_with_ids = sum(1 for s in bus_stations if s.get("stop_id"))
+        stations_with_coords = sum(1 for s in bus_stations if s.get("coordinates"))
+
+        # Logging analysis results
+        logger.info(f"Total stations: {len(bus_stations)}")
+        logger.info(
+            f"Stations with names: {stations_with_names} ({100*stations_with_names/len(bus_stations):.1f}%)"
+        )
+        logger.info(
+            f"Stations with IDs: {stations_with_ids} ({100*stations_with_ids/len(bus_stations):.1f}%)"
+        )
+        logger.info(
+            f"Stations with coordinates: {stations_with_coords} ({100*stations_with_coords/len(bus_stations):.1f}%)"
+        )
+
+        for range_name, count in duration_ranges.items():
+            percentage = 100 * count / len(bus_stations)
+            logger.info(f"  {range_name}: {count} stations ({percentage:.1f}%)")
+
+        # Quality assertions
+        assert len(bus_stations) > 0
+        assert stations_with_coords == len(bus_stations)  # All should have coordinates
+        assert (
+            stations_with_names > len(bus_stations) * 0.8
+        )  # At least 80% should have names
+
+        logger.info("\\n✅ Detailed analysis completed successfully")
+
+    except Exception as e:
+        logger.warning(f"Analysis failed: {e}")
+        pytest.skip(f"MOTIS API unavailable: {e}")
diff --git a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_bus_station_buffers.py b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_bus_station_buffers.py
deleted file mode 100644
index 0f0c7f777..000000000
--- a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_bus_station_buffers.py
+++ /dev/null
@@ -1,260 +0,0 @@
-import json
-import logging
-import time
-from pathlib import Path
-from typing import Any, Dict, List
-
-import geopandas as gpd
-import pytest
-from goatlib.analysis.schemas.vector import BufferParams
-from goatlib.analysis.vector.buffer import BufferTool
-from goatlib.routing.adapters.motis.motis_client import MotisServiceClient
-from goatlib.routing.adapters.motis.motis_converters import (
-    extract_bus_stations_for_buffering,
-    translate_to_motis_one_to_all_request,
-)
-from goatlib.routing.schemas.base import CatchmentAreaRoutingModePT
-from goatlib.routing.schemas.catchment_area_transit import (
-    TransitCatchmentAreaRequest,
-    TransitCatchmentAreaStartingPoints,
-    TransitCatchmentAreaTravelTimeCost,
-)
-from shapely.geometry import Point
-
-logger = logging.getLogger(__name__)
-
-# ==========================================
-#  Data Preparation Helper
-# ==========================================
-
-
-def create_pt_buffer_params(
-    reachable_locations: List[Dict[str, Any]],
-    config: Dict[str, Any],
-    work_dir: Path,
-) -> BufferParams:
-    """
-    Converts dictionary list to Parquet, then returns BufferParams.
-    """
-    # 1. Prepare Output Paths
-    input_path = work_dir / "motis_stations_input.parquet"
-    output_path = work_dir / "motis_stations_buffered.parquet"
-
-    # 2. Convert MOTIS list to GeoDataFrame
-    gdf_data = []
-    for station in reachable_locations:
-        coords = station["coordinates"]  # [lon, lat]
-        gdf_data.append(
-            {
-                "name": station.get("name", "Unknown"),
-                "duration_minutes": station.get("duration_minutes", 0),
-                "stop_id": station.get("stop_id", ""),
-                "geometry": Point(coords[0], coords[1]),
-            }
-        )
-
-    gdf = gpd.GeoDataFrame(gdf_data, crs="EPSG:4326")
-
-    # 3. Save Input Parquet (Required by BufferTool)
-    gdf.to_parquet(input_path)
-
-    # 4. Configure Tool
-    return BufferParams(
-        input_path=str(input_path),
-        output_path=str(output_path),
-        distances=config["distances"],  # e.g. [200, 400, 600]
-        units="meters",
-        dissolve=True,  # Merge overlapping circles into one shape
-        num_triangles=8,
-        cap_style="CAP_ROUND",
-        join_style="JOIN_ROUND",
-        output_crs="EPSG:4326",
-        output_name="pt_access_buffers",
-    )
-
-
-# ==========================================
-#  Configuration & Test
-# ==========================================
-
-
-@pytest.fixture
-def sample_request() -> TransitCatchmentAreaRequest:
-    """Munich City Center Request."""
-    starting_points = TransitCatchmentAreaStartingPoints(
-        lat=[48.1351],
-        lon=[11.582],  # Munich center
-    )
-    return TransitCatchmentAreaRequest(
-        starting_points=starting_points,
-        transit_modes=[
-            CatchmentAreaRoutingModePT.bus,
-            CatchmentAreaRoutingModePT.subway,
-            CatchmentAreaRoutingModePT.tram,
-            CatchmentAreaRoutingModePT.rail,
-        ],
-        travel_cost=TransitCatchmentAreaTravelTimeCost(max_traveltime=60, cutoffs=[60]),
-    )
-
-
-@pytest.fixture
-def pt_buffer_config() -> Dict[str, Any]:
-    """Single configuration for Public Transport Station Access."""
-    return {
-        "name": "pt_station_walk",
-        "title": "🚌 Public Transport Access",
-        "distances": [200, 400, 600],  # Walking distance from stations
-        "description": "Buffer zones around reachable stations",
-        "use_case": "Transit Coverage Analysis",
-    }
-
-
-@pytest.mark.asyncio
-async def test_public_transport_buffer_pipeline(
-    sample_request: TransitCatchmentAreaRequest,
-    pt_buffer_config: Dict[str, Any],
-    buffered_stations_dir: Path,
-) -> None:
-    """
-    1. Fetch MOTIS reachable stations.
-    2. Buffer them (200/400/600m).
-    3. Save Parquet.
-    """
-
-    buffered_stations_dir.mkdir(exist_ok=True)
-
-    # Fetch MOTIS Data
-    client = MotisServiceClient(use_fixtures=False)
-    try:
-        motis_req = translate_to_motis_one_to_all_request(sample_request)
-        logger.info("🚀 Requesting MOTIS One-to-All...")
-        motis_response = await client.one_to_all(motis_req)
-    finally:
-        await client.close()
-
-    bus_stations = extract_bus_stations_for_buffering(motis_response)
-    assert len(bus_stations) > 0, "No stations found. Cannot perform buffering."
-    logger.info(f"Found {len(bus_stations)} reachable stations.")
-
-    # Prepare & Buffer
-    params = create_pt_buffer_params(
-        reachable_locations=bus_stations,
-        config=pt_buffer_config,
-        work_dir=buffered_stations_dir,
-    )
-
-    logger.info("⚙️ Running BufferTool...")
-    tool = BufferTool()
-    results = tool.run(params)
-
-    # D. Assertions & Visualization
-    assert len(results) > 0
-    output_file, _ = results[0]
-
-    assert output_file.exists()
-    assert output_file.suffix == ".parquet"
-
-
-# ==========================================
-
-
-@pytest.mark.asyncio
-async def test_pipeline_performance(
-    sample_request: TransitCatchmentAreaRequest,
-    buffered_stations_dir: Path,
-    pt_buffer_config: Dict[str, Any],
-) -> None:
-    """Simplified timing test for MOTIS -> Buffer pipeline."""
-
-    buffered_stations_dir.mkdir(exist_ok=True)
-
-    # Setup timing stats
-    stats = {}
-    t_start = time.perf_counter()
-
-    # Phase 1: API Request
-    logger.info("⏱️ Phase 1: MOTIS API Request")
-    t_api = time.perf_counter()
-
-    client = MotisServiceClient(use_fixtures=False)
-    try:
-        motis_req = translate_to_motis_one_to_all_request(sample_request)
-        motis_response = await client.one_to_all(motis_req)
-    finally:
-        await client.close()
-
-    stats["api_latency_sec"] = round(time.perf_counter() - t_api, 4)
-
-    # Phase 2: Data Processing
-    logger.info("⏱️ Phase 2: Data Processing")
-    t_process = time.perf_counter()
-
-    bus_stations = extract_bus_stations_for_buffering(motis_response)
-    assert len(bus_stations) > 0, "No stations found for timing test"
-
-    stats["processing_sec"] = round(time.perf_counter() - t_process, 4)
-
-    # Phase 3: Buffer Creation
-    logger.info("⏱️ Phase 3: Buffer Creation")
-    t_buffer_setup = time.perf_counter()
-
-    params = create_pt_buffer_params(
-        reachable_locations=bus_stations,
-        config=pt_buffer_config,
-        work_dir=buffered_stations_dir,
-    )
-
-    stats["buffer_setup_sec"] = round(time.perf_counter() - t_buffer_setup, 4)
-
-    # BufferTool execution timing
-    t_buffer_run = time.perf_counter()
-    tool = BufferTool()
-    results = tool.run(params)
-    stats["buffer_tool_run_sec"] = round(time.perf_counter() - t_buffer_run, 4)
-
-    stats["buffering_total_sec"] = (
-        stats["buffer_setup_sec"] + stats["buffer_tool_run_sec"]
-    )
-    stats["total_time_sec"] = round(time.perf_counter() - t_start, 4)
-    stats["stations_processed"] = len(bus_stations)
-
-    # Log results
-    logger.info("🚀 Pipeline Performance Results:")
-    logger.info(f"   API Request: {stats['api_latency_sec']}s")
-    logger.info(f"   Processing: {stats['processing_sec']}s")
-    logger.info(f"   Buffer Setup: {stats['buffer_setup_sec']}s")
-    logger.info(f"   Buffer Tool Run: {stats['buffer_tool_run_sec']}s")
-    logger.info(f"   Buffering Total: {stats['buffering_total_sec']}s")
-    logger.info(f"   Total: {stats['total_time_sec']}s")
-    logger.info(f"   Stations: {stats['stations_processed']}")
-
-    # Save results to file
-    output_dir = buffered_stations_dir / "benchmarks"
-    output_dir.mkdir(exist_ok=True)
-
-    # Save as JSON
-    json_path = output_dir / "pipeline_performance.json"
-    with open(json_path, "w") as f:
-        json.dump(stats, f, indent=2)
-
-    # Save as readable text log
-    log_path = output_dir / "pipeline_performance.log"
-    with open(log_path, "w") as f:
-        f.write("Pipeline Performance Results:\n")
-        f.write(f"API Request: {stats['api_latency_sec']}s\n")
-        f.write(f"Processing: {stats['processing_sec']}s\n")
-        f.write(f"Buffer Setup: {stats['buffer_setup_sec']}s\n")
-        f.write(f"Buffer Tool Run: {stats['buffer_tool_run_sec']}s\n")
-        f.write(f"Buffering Total: {stats['buffering_total_sec']}s\n")
-        f.write(f"Total: {stats['total_time_sec']}s\n")
-        f.write(f"Stations: {stats['stations_processed']}\n")
-
-    logger.info("📁 Performance results saved to:")
-    logger.info(f"   JSON: {json_path.absolute()}")
-    logger.info(f"   Log: {log_path.absolute()}")
-
-    # Assertions
-    assert len(results) > 0
-    assert results[0][0].exists()  # Output file exists
-    assert stats["total_time_sec"] > 0
-    assert stats["stations_processed"] > 0
diff --git a/packages/python/goatlib/tests/integration/routing/conftest.py b/packages/python/goatlib/tests/integration/routing/conftest.py
index 40c81a0e6..101ee0432 100644
--- a/packages/python/goatlib/tests/integration/routing/conftest.py
+++ b/packages/python/goatlib/tests/integration/routing/conftest.py
@@ -2,11 +2,10 @@
 
 import pytest_asyncio
 from goatlib.routing.adapters.motis import MotisPlanApiAdapter, create_motis_adapter
-from goatlib.routing.schemas.base import AccessEgressMode, CatchmentAreaRoutingModePT
+from goatlib.routing.schemas.base import CatchmentAreaRoutingModePT
 from goatlib.routing.schemas.catchment_area_transit import (
+    AccessEgressSettings,
     TransitCatchmentAreaRequest,
-    TransitCatchmentAreaStartingPoints,
-    TransitCatchmentAreaTravelTimeCost,
 )
 
 
@@ -19,87 +18,57 @@ async def motis_adapter_online() -> AsyncGenerator[MotisPlanApiAdapter, None]:
     - Makes real HTTP requests to api.transitous.org
     - Should be used for tests that need real API validation
     """
-    adapter = create_motis_adapter(use_fixtures=False)
+    adapter = create_motis_adapter()
     yield adapter
     await adapter.motis_client.close()
 
 
-@pytest_asyncio.fixture
-async def motis_adapter_fixture(
-    motis_fixtures_dir: str,
-) -> AsyncGenerator[MotisPlanApiAdapter, None]:
-    """
-    MOTIS adapter for fixture-based testing using local test data.
-
-    This adapter:
-    - Uses local fixture files (no network requests)
-    - Very fast execution
-    - Deterministic results
-    """
-    adapter = create_motis_adapter(use_fixtures=True, fixture_path=motis_fixtures_dir)
-    yield adapter
-    if hasattr(adapter.motis_client, "close"):
-        await adapter.motis_client.close()
-
-
 # Common test data fixtures for one-to-all testing
 @pytest_asyncio.fixture
 def berlin_request() -> TransitCatchmentAreaRequest:
     """Create a standard Berlin transit catchment area request."""
-    starting_points = TransitCatchmentAreaStartingPoints(
-        lat=[52.5200],
-        lon=[13.4050],  # Berlin center
-    )
     return TransitCatchmentAreaRequest(
-        starting_points=starting_points,
+        starting_points=[
+            {"lat": 52.5200, "lon": 13.4050}  # Berlin center
+        ],
         transit_modes=[
             CatchmentAreaRoutingModePT.bus,
             CatchmentAreaRoutingModePT.tram,
             CatchmentAreaRoutingModePT.subway,
         ],
-        access_mode=AccessEgressMode.walk,
-        egress_mode=AccessEgressMode.walk,
-        travel_cost=TransitCatchmentAreaTravelTimeCost(
-            max_traveltime=30,
-            cutoffs=[15, 30],  # 15 and 30 minute isochrones
-        ),
+        cutoffs=[15, 30],  # 15 and 30 minute isochrones
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
     )
 
 
 @pytest_asyncio.fixture
 def munich_request() -> TransitCatchmentAreaRequest:
     """Create a Munich transit catchment area request for testing."""
-    starting_points = TransitCatchmentAreaStartingPoints(
-        lat=[48.1351],
-        lon=[11.5820],  # Munich center
-    )
     return TransitCatchmentAreaRequest(
-        starting_points=starting_points,
+        starting_points=[
+            {"lat": 48.1351, "lon": 11.5820}  # Munich center
+        ],
         transit_modes=[
             CatchmentAreaRoutingModePT.rail,
             CatchmentAreaRoutingModePT.subway,
             CatchmentAreaRoutingModePT.tram,
         ],
-        access_mode=AccessEgressMode.walk,
-        egress_mode=AccessEgressMode.walk,
-        travel_cost=TransitCatchmentAreaTravelTimeCost(
-            max_traveltime=45,
-            cutoffs=[15, 30, 45],  # Three isochrone bands
-        ),
+        cutoffs=[15, 30, 45],  # Three isochrone bands
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
     )
 
 
 @pytest_asyncio.fixture
 def simple_berlin_request() -> TransitCatchmentAreaRequest:
     """Create a simple Berlin request for minimal testing."""
-    starting_points = TransitCatchmentAreaStartingPoints(
-        lat=[52.5200],
-        lon=[13.4050],  # Berlin
-    )
     return TransitCatchmentAreaRequest(
-        starting_points=starting_points,
+        starting_points=[
+            {"lat": 52.5200, "lon": 13.4050}  # Berlin
+        ],
         transit_modes=[CatchmentAreaRoutingModePT.subway],
-        access_mode=AccessEgressMode.walk,
-        egress_mode=AccessEgressMode.walk,
-        travel_cost=TransitCatchmentAreaTravelTimeCost(max_traveltime=15, cutoffs=[15]),
+        cutoffs=[15],
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
     )
diff --git a/packages/python/goatlib/tests/unit/routing/test_catchment.py b/packages/python/goatlib/tests/unit/routing/test_catchment.py
deleted file mode 100644
index b37fb5fc3..000000000
--- a/packages/python/goatlib/tests/unit/routing/test_catchment.py
+++ /dev/null
@@ -1,188 +0,0 @@
-import pytest
-from goatlib.routing.schemas.base import CatchmentAreaType
-from goatlib.routing.schemas.catchment import Catchment
-from pydantic import ValidationError
-
-"""Test cases for Catchment validation and functionality."""
-
-
-def test_valid_catchment_schema_creation() -> None:
-    """Test creating a valid catchment schema."""
-    data = {
-        "starting_points": [
-            {"lon": 11.123, "lat": 48.1234},
-            {"lon": 11.456, "lat": 48.5678},
-        ],
-        "cutoffs": [10.0, 20.0, 30.0],
-        "type": "polygon",
-    }
-
-    schema = Catchment(**data)
-    assert len(schema.starting_points) == 2
-    assert schema.starting_points[0].lon == 11.123
-    assert schema.starting_points[0].lat == 48.1234
-    assert schema.starting_points[1].lon == 11.456
-    assert schema.starting_points[1].lat == 48.5678
-    assert schema.cutoffs == [10.0, 20.0, 30.0]
-    assert schema.type == CatchmentAreaType.polygon
-
-
-def test_coordinate_validation_longitude() -> None:
-    """Test longitude coordinate validation."""
-    # Valid longitude range
-    valid_data = {
-        "starting_points": [
-            {"lon": -180.0, "lat": 48.1},
-            {"lon": 0.0, "lat": 48.1},
-            {"lon": 180.0, "lat": 48.1},
-        ],
-        "cutoffs": [10.0],
-        "type": "point",
-    }
-    schema = Catchment(**valid_data)
-    assert len(schema.starting_points) == 3
-
-    # Invalid longitude - too low
-    with pytest.raises(ValidationError) as exc_info:
-        Catchment(
-            starting_points=[{"lon": -180.1, "lat": 48.1}],
-            cutoffs=[10.0],
-            type="point",
-        )
-    assert "greater than or equal to -180" in str(exc_info.value)
-
-    # Invalid longitude - too high
-    with pytest.raises(ValidationError) as exc_info:
-        Catchment(
-            starting_points=[{"lon": 180.1, "lat": 48.1}],
-            cutoffs=[10.0],
-            type="point",
-        )
-    assert "less than or equal to 180" in str(exc_info.value)
-
-
-def test_coordinate_validation_latitude() -> None:
-    """Test latitude coordinate validation."""
-    # Valid latitude range
-    valid_data = {
-        "starting_points": [
-            {"lon": 11.0, "lat": -90.0},
-            {"lon": 11.0, "lat": 0.0},
-            {"lon": 11.0, "lat": 90.0},
-        ],
-        "cutoffs": [10.0],
-        "type": "point",
-    }
-    schema = Catchment(**valid_data)
-    assert len(schema.starting_points) == 3
-
-    # Invalid latitude - too low
-    with pytest.raises(ValidationError) as exc_info:
-        Catchment(
-            starting_points=[{"lon": 11.0, "lat": -90.1}],
-            cutoffs=[10.0],
-            type="point",
-        )
-    assert "greater than or equal to -90" in str(exc_info.value)
-
-    # Invalid latitude - too high
-    with pytest.raises(ValidationError) as exc_info:
-        Catchment(
-            starting_points=[{"lon": 11.0, "lat": 90.1}],
-            cutoffs=[10.0],
-            type="point",
-        )
-    assert "less than or equal to 90" in str(exc_info.value)
-
-
-def test_invalid_coordinate_count() -> None:
-    """Test validation of coordinate structure."""
-    # Missing required field
-    with pytest.raises(ValidationError) as exc_info:
-        Catchment(
-            starting_points=[{"lon": 11.123}],  # Missing lat
-            cutoffs=[10.0],
-            type="point",
-        )
-    assert "Field required" in str(exc_info.value)
-
-    # Invalid format (list instead of dict)
-    with pytest.raises(ValidationError) as exc_info:
-        Catchment(
-            starting_points=[[11.123, 48.1234]],  # Should be dict
-            cutoffs=[10.0],
-            type="point",
-        )
-    assert "Input should be a valid dictionary" in str(exc_info.value)
-
-
-def test_empty_starting_points() -> None:
-    """Test validation with empty starting points."""
-    with pytest.raises(ValidationError) as exc_info:
-        Catchment(starting_points=[], cutoffs=[10.0], type="point")
-    assert "at least 1" in str(exc_info.value).lower()
-
-
-def test_cutoffs_validation() -> None:
-    """Test cutoffs validation."""
-    base_data = {
-        "starting_points": [{"lon": 11.123, "lat": 48.1234}],
-        "type": "point",
-    }
-
-    # Negative cutoff
-    with pytest.raises(ValidationError) as exc_info:
-        Catchment(cutoffs=[-5.0], **base_data)
-    assert "must be positive" in str(exc_info.value)
-
-    # Zero cutoff
-    with pytest.raises(ValidationError) as exc_info:
-        Catchment(cutoffs=[0.0], **base_data)
-    assert "must be positive" in str(exc_info.value)
-
-    # Unsorted cutoffs should be auto-sorted without error
-    schema = Catchment(cutoffs=[20.0, 10.0, 30.0], **base_data)
-    assert schema.cutoffs == [10.0, 20.0, 30.0]
-
-
-def test_empty_cutoffs() -> None:
-    """Test validation with empty cutoffs."""
-    with pytest.raises(ValidationError) as exc_info:
-        Catchment(
-            starting_points=[{"lon": 11.123, "lat": 48.1234}],
-            cutoffs=[],
-            type="point",
-        )
-    assert "at least 1" in str(exc_info.value).lower()
-
-
-def test_invalid_catchment_type() -> None:
-    """Test validation with invalid catchment type."""
-    with pytest.raises(ValidationError) as exc_info:
-        Catchment(
-            starting_points=[{"lon": 11.123, "lat": 48.1234}],
-            cutoffs=[10.0],
-            type="invalid_type",
-        )
-    assert "Input should be" in str(exc_info.value)
-
-
-def test_example_from_user_request() -> None:
-    """Test the exact example provided in the user request."""
-    data = {
-        "starting_points": [
-            {"lon": 11.123, "lat": 12.34},
-            {"lon": 48.11, "lat": 48.1234},
-        ],
-        "cutoffs": [10.0, 20.0, 30.0],
-        "type": "polygon",
-    }
-
-    schema = Catchment(**data)
-    assert len(schema.starting_points) == 2
-    assert schema.starting_points[0].lon == 11.123
-    assert schema.starting_points[0].lat == 12.34
-    assert schema.starting_points[1].lon == 48.11
-    assert schema.starting_points[1].lat == 48.1234
-    assert schema.cutoffs == [10.0, 20.0, 30.0]
-    assert schema.type == CatchmentAreaType.polygon
diff --git a/packages/python/goatlib/tests/unit/routing/test_catchment_area_transit.py b/packages/python/goatlib/tests/unit/routing/test_catchment_area_transit.py
index 85aa70e06..d2b4a866d 100644
--- a/packages/python/goatlib/tests/unit/routing/test_catchment_area_transit.py
+++ b/packages/python/goatlib/tests/unit/routing/test_catchment_area_transit.py
@@ -1,121 +1,147 @@
 import pytest
+from goatlib.routing.schemas.base import AccessEgressMode, CatchmentAreaRoutingModePT
 from goatlib.routing.schemas.catchment_area_transit import (
-    AccessEgressMode,
+    AccessEgressSettings,
     CatchmentAreaPolygon,
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaResponse,
-    TransitCatchmentAreaStartingPoints,
-    TransitCatchmentAreaTravelTimeCost,
-    TransitRoutingSettings,
 )
 
 
 def test_valid_single_point() -> None:
-    """Test creating valid single starting point."""
-    starting_points = TransitCatchmentAreaStartingPoints(lat=[52.5200], lon=[13.4050])
-    assert starting_points.lat == [52.5200]
-    assert starting_points.lon == [13.4050]
+    """Test creating valid transit catchment area request."""
+    request = TransitCatchmentAreaRequest(
+        starting_points=[{"lat": 52.5200, "lon": 13.4050}],
+        transit_modes=[CatchmentAreaRoutingModePT.bus],
+        cutoffs=[15, 30],
+    )
+    assert len(request.starting_points) == 1
+    assert request.starting_points[0].lat == 52.5200
+    assert request.starting_points[0].lon == 13.4050
 
 
 def test_reject_multiple_points() -> None:
     """Test that multiple starting points are rejected."""
-    with pytest.raises(ValueError, match="exactly one starting point"):
-        TransitCatchmentAreaStartingPoints(
-            lat=[52.5200, 52.5300], lon=[13.4050, 13.4150]
+    with pytest.raises(ValueError, match="at most 1 item"):
+        TransitCatchmentAreaRequest(
+            starting_points=[
+                {"lat": 52.5200, "lon": 13.4050},
+                {"lat": 52.5300, "lon": 13.4150},
+            ],
+            transit_modes=[CatchmentAreaRoutingModePT.bus],
+            cutoffs=[15, 30],
         )
 
 
-def test_valid_travel_cost() -> None:
-    """Test creating valid travel cost configuration."""
-    travel_cost = TransitCatchmentAreaTravelTimeCost(
-        max_traveltime=60, cutoffs=[15, 30, 45, 60]
+def test_valid_cutoffs() -> None:
+    """Test creating valid cutoffs configuration."""
+    request = TransitCatchmentAreaRequest(
+        starting_points=[{"lat": 52.5200, "lon": 13.4050}],
+        transit_modes=[CatchmentAreaRoutingModePT.bus],
+        cutoffs=[15, 30, 45, 60],
     )
-    assert travel_cost.max_traveltime == 60
-    assert travel_cost.cutoffs == [15, 30, 45, 60]
+    assert request.cutoffs == [15, 30, 45, 60]
 
 
-def test_cutoffs_exceed_max_time() -> None:
-    """Test that cutoffs exceeding max travel time are rejected."""
-    with pytest.raises(ValueError, match="exceed maximum travel time"):
-        TransitCatchmentAreaTravelTimeCost(max_traveltime=30, cutoffs=[15, 45, 60])
+def test_unsorted_cutoffs_auto_fix() -> None:
+    """Test that unsorted cutoffs are automatically sorted."""
+    request = TransitCatchmentAreaRequest(
+        starting_points=[{"lat": 52.5200, "lon": 13.4050}],
+        transit_modes=[CatchmentAreaRoutingModePT.bus],
+        cutoffs=[30, 15, 45, 60],  # Unsorted input
+    )
+    # Should be automatically sorted and deduplicated
+    assert request.cutoffs == [15, 30, 45, 60]
 
 
 def test_negative_cutoffs() -> None:
     """Test that negative cutoffs are rejected."""
     with pytest.raises(ValueError, match="must be positive"):
-        TransitCatchmentAreaTravelTimeCost(max_traveltime=60, cutoffs=[-15, 30, 45])
-
-
-def test_unsorted_cutoffs() -> None:
-    """Test that unsorted cutoffs are rejected."""
-    with pytest.raises(ValueError, match="ascending order"):
-        TransitCatchmentAreaTravelTimeCost(max_traveltime=60, cutoffs=[30, 15, 45, 60])
+        TransitCatchmentAreaRequest(
+            starting_points=[{"lat": 52.5200, "lon": 13.4050}],
+            transit_modes=[CatchmentAreaRoutingModePT.bus],
+            cutoffs=[-15, 30, 45],
+        )
 
 
 def test_valid_request() -> None:
-    """Test creating a valid transit isochrone request."""
-    request_data = {
-        "starting_points": {"lat": [52.5200], "lon": [13.4050]},
-        "transit_modes": ["bus", "tram"],
-        "travel_cost": {
-            "max_traveltime": 60,
-            "cutoffs": [15, 30, 45, 60],
-        },
-    }
+    """Test creating a valid transit catchment area request."""
+    request = TransitCatchmentAreaRequest(
+        starting_points=[{"lat": 52.5200, "lon": 13.4050}],
+        transit_modes=[CatchmentAreaRoutingModePT.bus, CatchmentAreaRoutingModePT.tram],
+        cutoffs=[15, 30, 45, 60],
+    )
 
-    request = TransitCatchmentAreaRequest(**request_data)
-    assert len(request.starting_points.lat) == 1
+    assert len(request.starting_points) == 1
     assert len(request.transit_modes) == 2
-    assert request.travel_cost.max_traveltime == 60
+    assert len(request.cutoffs) == 4
 
 
 def test_bike_access_request() -> None:
     """Test transit request with bicycle access mode."""
-    request_data = {
-        "starting_points": {"lat": [52.5200], "lon": [13.4050]},
-        "transit_modes": ["rail", "subway"],
-        "travel_cost": {"max_traveltime": 45, "cutoffs": [15, 30, 45]},
-        "routing_settings": {
-            "access_settings": {"mode": "bicycle", "max_time": 25, "speed": 15.0}
-        },
-    }
+    request = TransitCatchmentAreaRequest(
+        starting_points=[{"lat": 52.5200, "lon": 13.4050}],
+        transit_modes=[
+            CatchmentAreaRoutingModePT.rail,
+            CatchmentAreaRoutingModePT.subway,
+        ],
+        cutoffs=[15, 30, 45],
+        access_settings=AccessEgressSettings(
+            mode=AccessEgressMode.bicycle, max_time=25, speed=15.0
+        ),
+    )
 
-    request = TransitCatchmentAreaRequest(**request_data)
     assert request.access_mode == AccessEgressMode.bicycle
-    assert request.routing_settings.access_settings.max_time == 25
-
-
-def test_routing_settings() -> None:
-    """Test routing settings configuration."""
-    routing_settings = TransitRoutingSettings()
-
-    # Test default values
-    assert routing_settings.max_transfers == 4
-    assert routing_settings.access_settings.max_time == 15
-    assert routing_settings.access_settings.speed == 5.0
-    assert routing_settings.egress_settings.max_time == 15
-    assert routing_settings.egress_settings.speed == 5.0
-
-
-def test_custom_routing_settings() -> None:
-    """Test custom routing settings."""
-    routing_settings = TransitRoutingSettings(
+    assert request.access_settings.max_time == 25
+
+
+def test_access_egress_settings() -> None:
+    """Test access and egress settings configuration."""
+    # Test default walk settings
+    walk_settings = AccessEgressSettings.create_walk_settings()
+    assert walk_settings.mode == AccessEgressMode.walk
+    assert walk_settings.max_time == 15
+    assert walk_settings.speed == 5.0
+
+    # Test default bike settings
+    bike_settings = AccessEgressSettings.create_bike_settings()
+    assert bike_settings.mode == AccessEgressMode.bicycle
+    assert bike_settings.max_time == 20
+    assert bike_settings.speed == 15.0
+
+
+def test_custom_request_configuration() -> None:
+    """Test custom transit request configuration."""
+    request = TransitCatchmentAreaRequest(
+        starting_points=[{"lat": 52.5200, "lon": 13.4050}],
+        transit_modes=[CatchmentAreaRoutingModePT.bus, CatchmentAreaRoutingModePT.tram],
+        cutoffs=[15, 30, 45],
         max_transfers=6,
-        access_settings={"mode": "walk", "max_time": 20, "speed": 4.5},
-        egress_settings={"mode": "bicycle", "max_time": 30, "speed": 18.0},
+        access_settings=AccessEgressSettings(
+            mode=AccessEgressMode.walk, max_time=20, speed=4.5
+        ),
+        egress_settings=AccessEgressSettings(
+            mode=AccessEgressMode.bicycle, max_time=30, speed=18.0
+        ),
     )
 
-    assert routing_settings.max_transfers == 6
-    assert routing_settings.access_settings.max_time == 20
-    assert routing_settings.access_settings.speed == 4.5
-    assert routing_settings.egress_settings.max_time == 30
-    assert routing_settings.egress_settings.speed == 18.0
+    assert request.max_transfers == 6
+    assert request.access_settings.max_time == 20
+    assert request.access_settings.speed == 4.5
+    assert request.egress_settings.max_time == 30
+    assert request.egress_settings.speed == 18.0
 
 
 def test_catchment_area_polygon() -> None:
     """Test catchment area polygon response structure."""
     polygon = CatchmentAreaPolygon(
         travel_time=30,
+        points=[
+            {"lat": 0, "lon": 0},
+            {"lat": 0, "lon": 1},
+            {"lat": 1, "lon": 1},
+            {"lat": 1, "lon": 0},
+        ],
         geometry={
             "type": "Polygon",
             "coordinates": [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
@@ -124,6 +150,7 @@ def test_catchment_area_polygon() -> None:
 
     assert polygon.travel_time == 30
     assert polygon.geometry["type"] == "Polygon"
+    assert len(polygon.points) == 4
 
 
 def test_transit_response() -> None:
@@ -131,6 +158,12 @@ def test_transit_response() -> None:
     polygons = [
         CatchmentAreaPolygon(
             travel_time=15,
+            points=[
+                {"lat": 0, "lon": 0},
+                {"lat": 0, "lon": 1},
+                {"lat": 1, "lon": 1},
+                {"lat": 1, "lon": 0},
+            ],
             geometry={
                 "type": "Polygon",
                 "coordinates": [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
@@ -138,6 +171,12 @@ def test_transit_response() -> None:
         ),
         CatchmentAreaPolygon(
             travel_time=30,
+            points=[
+                {"lat": 0, "lon": 0},
+                {"lat": 0, "lon": 2},
+                {"lat": 2, "lon": 2},
+                {"lat": 2, "lon": 0},
+            ],
             geometry={
                 "type": "Polygon",
                 "coordinates": [[[0, 0], [2, 0], [2, 2], [0, 2], [0, 0]]],
diff --git a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_plausibility.py b/packages/python/goatlib/tests/unit/routing/test_motis_one_to_all.py
similarity index 86%
rename from packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_plausibility.py
rename to packages/python/goatlib/tests/unit/routing/test_motis_one_to_all.py
index 3dbeacdc8..558df39cc 100644
--- a/packages/python/goatlib/tests/benchmarks/test_motis_one_to_all_plausibility.py
+++ b/packages/python/goatlib/tests/unit/routing/test_motis_one_to_all.py
@@ -9,12 +9,10 @@
     parse_motis_one_to_all_response,
     translate_to_motis_one_to_all_request,
 )
-from goatlib.routing.schemas.base import AccessEgressMode, CatchmentAreaRoutingModePT
+from goatlib.routing.schemas.base import CatchmentAreaRoutingModePT
 from goatlib.routing.schemas.catchment_area_transit import (
+    AccessEgressSettings,
     TransitCatchmentAreaRequest,
-    TransitCatchmentAreaStartingPoints,
-    TransitCatchmentAreaTravelTimeCost,
-    TransitRoutingSettings,
 )
 
 logger = logging.getLogger(__name__)
@@ -124,26 +122,19 @@ async def run_comprehensive_test(self) -> Dict[str, Any]:
         """Run comprehensive plausibility testing."""
         logger.info("🧪 MOTIS One-to-All Plausibility Test")
 
-        adapter = create_motis_adapter(use_fixtures=False)
+        adapter = create_motis_adapter()
 
         try:
             # Create test request
             request = TransitCatchmentAreaRequest(
-                starting_points=TransitCatchmentAreaStartingPoints(
-                    lat=[48.1351],
-                    lon=[11.5820],
-                ),
+                starting_points=[{"lat": 48.1351, "lon": 11.5820}],
                 transit_modes=[
                     CatchmentAreaRoutingModePT.bus,
                     CatchmentAreaRoutingModePT.subway,
                 ],
-                access_mode=AccessEgressMode.walk,
-                egress_mode=AccessEgressMode.walk,
-                travel_cost=TransitCatchmentAreaTravelTimeCost(
-                    max_traveltime=30,
-                    cutoffs=[10, 20, 30],
-                ),
-                routing_settings=TransitRoutingSettings(),
+                cutoffs=[10, 20, 30],
+                access_settings=AccessEgressSettings.create_walk_settings(),
+                egress_settings=AccessEgressSettings.create_walk_settings(),
             )
 
             # Get MOTIS response
@@ -188,12 +179,11 @@ async def run_comprehensive_test(self) -> Dict[str, Any]:
                 "test_location": "Munich, Germany",
                 "request_params": {
                     "starting_point": [
-                        request.starting_points.lat[0],
-                        request.starting_points.lon[0],
+                        request.starting_points[0].lat,
+                        request.starting_points[0].lon,
                     ],
                     "transit_modes": [mode.value for mode in request.transit_modes],
-                    "max_travel_time": request.travel_cost.max_traveltime,
-                    "cutoffs": request.travel_cost.cutoffs,
+                    "cutoffs": request.cutoffs,
                 },
                 "motis_request": motis_request_data,
                 "raw_response_stats": {
@@ -248,44 +238,37 @@ def plausibility_tester():
 def sample_request():
     """Fixture providing a sample transit catchment area request."""
     return TransitCatchmentAreaRequest(
-        starting_points=TransitCatchmentAreaStartingPoints(
-            lat=[48.1351],
-            lon=[11.5820],  # Munich city center
-        ),
+        starting_points=[
+            {"lat": 48.1351, "lon": 11.5820}  # Munich city center
+        ],
         transit_modes=[
             CatchmentAreaRoutingModePT.bus,
             CatchmentAreaRoutingModePT.subway,
         ],
-        access_mode=AccessEgressMode.walk,
-        egress_mode=AccessEgressMode.walk,
-        travel_cost=TransitCatchmentAreaTravelTimeCost(
-            max_traveltime=30,
-            cutoffs=[10, 20, 30],
-        ),
-        routing_settings=TransitRoutingSettings(),
+        cutoffs=[10, 20, 30],
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
     )
 
 
+@pytest.mark.network
 @pytest.mark.asyncio
 async def test_motis_one_to_all_raw_response_validation(plausibility_tester):
     """Test that MOTIS one-to-all returns a valid response structure."""
-    adapter = create_motis_adapter(use_fixtures=False)
+    adapter = create_motis_adapter()
 
     try:
         request = TransitCatchmentAreaRequest(
-            starting_points=TransitCatchmentAreaStartingPoints(
-                lat=[48.1351],
-                lon=[11.5820],
-            ),
+            starting_points=[{"lat": 48.1351, "lon": 11.5820}],
             transit_modes=[CatchmentAreaRoutingModePT.bus],
-            travel_cost=TransitCatchmentAreaTravelTimeCost(
-                max_traveltime=20,
-                cutoffs=[10, 20],
-            ),
+            cutoffs=[10, 20],
         )
 
         motis_request = translate_to_motis_one_to_all_request(request)
-        motis_response = await adapter.motis_client.one_to_all(motis_request)
+        try:
+            motis_response = await adapter.motis_client.one_to_all(motis_request)
+        except Exception as e:
+            pytest.skip(f"MOTIS one-to-all service unavailable: {e}")
 
         # Validate response structure
         issues = plausibility_tester.validate_raw_motis_response(motis_response)
@@ -308,14 +291,18 @@ async def test_motis_one_to_all_raw_response_validation(plausibility_tester):
         await adapter.motis_client.close()
 
 
+@pytest.mark.network
 @pytest.mark.asyncio
 async def test_motis_response_parsing(sample_request):
     """Test that MOTIS response can be parsed into our internal format."""
-    adapter = create_motis_adapter(use_fixtures=False)
+    adapter = create_motis_adapter()
 
     try:
         motis_request = translate_to_motis_one_to_all_request(sample_request)
-        motis_response = await adapter.motis_client.one_to_all(motis_request)
+        try:
+            motis_response = await adapter.motis_client.one_to_all(motis_request)
+        except Exception as e:
+            pytest.skip(f"MOTIS one-to-all service unavailable: {e}")
 
         # Parse the response
         parsed_response = parse_motis_one_to_all_response(
@@ -328,29 +315,38 @@ async def test_motis_response_parsing(sample_request):
         assert len(parsed_response.polygons) > 0, "Should generate at least one polygon"
 
         # Check polygon structure
+        max_cutoff = max(sample_request.cutoffs)
         for polygon in parsed_response.polygons:
             assert hasattr(polygon, "travel_time"), "Polygon should have travel_time"
             assert polygon.travel_time > 0, "Travel time should be positive"
             assert (
-                polygon.travel_time <= sample_request.travel_cost.max_traveltime
+                polygon.travel_time <= max_cutoff
             ), "Travel time should not exceed maximum"
 
     finally:
         await adapter.motis_client.close()
 
 
+@pytest.mark.network
 @pytest.mark.asyncio
 async def test_adapter_consistency(sample_request):
     """Test that adapter and direct parsing produce consistent results."""
-    adapter = create_motis_adapter(use_fixtures=False)
+    adapter = create_motis_adapter()
 
     try:
         # Get response through adapter
-        adapter_response = await adapter.get_transit_catchment_area(sample_request)
+        try:
+            adapter_response = await adapter._get_transit_catchment_area(sample_request)
+        except Exception as e:
+            pytest.skip(f"MOTIS adapter service unavailable: {e}")
 
         # Get response directly and parse
         motis_request = translate_to_motis_one_to_all_request(sample_request)
-        motis_response = await adapter.motis_client.one_to_all(motis_request)
+        try:
+            motis_response = await adapter.motis_client.one_to_all(motis_request)
+        except Exception as e:
+            pytest.skip(f"MOTIS one-to-all service unavailable: {e}")
+
         direct_response = parse_motis_one_to_all_response(
             motis_response, sample_request
         )
@@ -371,10 +367,14 @@ async def test_adapter_consistency(sample_request):
         await adapter.motis_client.close()
 
 
+@pytest.mark.network
 @pytest.mark.asyncio
 async def test_comprehensive_plausibility(plausibility_tester):
     """Run comprehensive plausibility test and verify results."""
-    results = await plausibility_tester.run_comprehensive_test()
+    try:
+        results = await plausibility_tester.run_comprehensive_test()
+    except Exception as e:
+        pytest.skip(f"MOTIS plausibility test service unavailable: {e}")
 
     # Should not have errored
     assert (
diff --git a/packages/python/goatlib/tests/utils/ab_route_validator.py b/packages/python/goatlib/tests/utils/ab_route_validator.py
index d25fef0a9..029685a05 100644
--- a/packages/python/goatlib/tests/utils/ab_route_validator.py
+++ b/packages/python/goatlib/tests/utils/ab_route_validator.py
@@ -29,7 +29,7 @@ class RouteValidator:
     def __init__(self) -> None:
         # Speed limits in km/h for different modes
         self.max_speeds = {
-            Mode.walk: 8.0,  # Fast walking
+            Mode.walk: 15.0,  # Allow for jogging/fast walking scenarios
             Mode.bicycle: 35.0,  # E-bike or very fast cycling
             Mode.car: 120.0,  # Highway speeds
             Mode.bus: 80.0,  # Urban bus max speed
@@ -252,10 +252,10 @@ def _validate_leg(self, leg: ABLeg, index: int) -> List[PlausibilityIssue]:
                     )
                 )
 
-        # Distance validation - simplified approach to avoid MOTIS calculation issues
+        # Distance validation - adjusted for long-distance routes
         if leg.distance and leg.distance > 0:
-            # Only flag obviously problematic distances
-            if leg.distance > 100000:  # More than 100km for a single leg
+            # Only flag extremely problematic distances (more than 600km for a single leg)
+            if leg.distance > 600000:  # More than 600km for a single leg
                 issues.append(
                     PlausibilityIssue(
                         "warning",

From ab5986dc79fe29d2a77ab3ab8460ad0e9d31afa3 Mon Sep 17 00:00:00 2001
From: 96hoshi <marta.locascio@plan4better.de>
Date: Thu, 18 Dec 2025 17:03:08 +0000
Subject: [PATCH 09/11] test: added complete workflow to improve

---
 .../catchment/test_routing_workflow.py        | 280 ++++++++++++++++++
 1 file changed, 280 insertions(+)
 create mode 100644 packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py

diff --git a/packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py b/packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py
new file mode 100644
index 000000000..a86122c22
--- /dev/null
+++ b/packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py
@@ -0,0 +1,280 @@
+import logging
+import os
+from pathlib import Path
+
+import pytest
+from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
+from goatlib.routing.adapters.motis import create_motis_adapter
+from goatlib.routing.schemas.base import (
+    CatchmentAreaRoutingModePT,
+    Coordinates,
+)
+from goatlib.routing.schemas.catchment_area_transit import (
+    AccessEgressSettings,
+    TransitCatchmentAreaRequest,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.mark.asyncio
+@pytest.mark.network
+async def test_complete_motis_rust_workflow():
+    """Complete MOTIS + Rust workflow using the correct adapter interface."""
+
+    logger.info("🚀 Starting complete MOTIS + Rust workflow...")
+
+    # Test data path
+    test_file = Path("/app/packages/python/goatlib/tests/data/network/network.parquet")
+    if not test_file.exists():
+        pytest.skip(f"Test file not found: {test_file}")
+
+    # Step 1: Use MOTIS adapter directly with the interface
+    logger.info("📡 Step 1: Getting transit catchment area from MOTIS...")
+    center = Coordinates(lat=48.1351, lon=11.5820)  # Munich center
+    motis_request = TransitCatchmentAreaRequest(
+        starting_points=[center],  # Munich
+        transit_modes=[
+            CatchmentAreaRoutingModePT.rail,
+            CatchmentAreaRoutingModePT.subway,
+            CatchmentAreaRoutingModePT.tram,
+        ],
+        cutoffs=[15],  # 15 minutes
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
+    )
+
+    # Use the MOTIS client directly to get raw station data
+    adapter = create_motis_adapter()
+    try:
+        # Get raw MOTIS data using the converter functions
+        from goatlib.routing.adapters.motis.motis_converters import (
+            extract_bus_stations_for_buffering,
+            translate_to_motis_one_to_all_request,
+        )
+
+        # Convert our request to MOTIS format and call directly
+        motis_req = translate_to_motis_one_to_all_request(motis_request)
+        logger.info(f"🔄 MOTIS request: {motis_req}")
+
+        raw_motis_response = await adapter.motis_client.one_to_all(motis_req)
+        logger.info("✅ MOTIS raw response received")
+
+        # Extract stations from the raw response
+        raw_stations = extract_bus_stations_for_buffering(raw_motis_response)
+        logger.info(f"📍 Extracted {len(raw_stations)} transit stations")
+
+        if not raw_stations:
+            logger.info("❌ No stations found in MOTIS response")
+            pytest.skip("No station data from MOTIS")
+
+        # Show first few stations for debugging
+        for i, station in enumerate(raw_stations):
+            coords = station["coordinates"]  # [lon, lat]
+            logger.info(
+                f"   Station {i+1}: {station.get('name', 'Unknown')} at [{coords[1]:.4f}, {coords[0]:.4f}]"
+            )
+
+        # Convert to our format
+        stations_data = []
+        for station in raw_stations:
+            coords = station["coordinates"]  # [lon, lat]
+            stations_data.append(
+                {
+                    "name": station.get("name", "Unknown"),
+                    "lat": coords[1],  # latitude
+                    "lon": coords[0],  # longitude
+                    "transit_time": station.get("duration_minutes", 0),
+                }
+            )
+
+    except Exception as e:
+        await adapter.motis_client.close()
+        logger.error(f"MOTIS API error: {e}")
+        pytest.skip(f"MOTIS API unavailable: {e}")
+
+    await adapter.motis_client.close()
+
+    # Step 2: Process with Rust routing using the fast functions
+    logger.info("⚙️ Step 2: Testing Rust routing on transit stations...")
+
+    successful_routing = 0
+    total_reachable = 0
+
+    with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
+        # Load network around Munich - larger area to ensure we catch stations
+        subset_table = proc.load_network(
+            center=center, buffer_radius=15000.0
+        )  # 15km radius
+        logger.info(f"📊 Loaded network subset: {subset_table}")
+
+        # Process all stations in batch using calculate_multiple_isochrones
+        station_coordinates = [
+            Coordinates(lat=station["lat"], lon=station["lon"])
+            for station in stations_data
+        ]
+        logger.info(f"🔧 Processing {len(station_coordinates)} stations in batch...")
+
+        try:
+            # Create artificial nodes for all stations at once
+            result = proc.create_artificial_nodes_for_points(
+                station_coordinates, subset_table, search_radius_m=500.0
+            )
+
+            if isinstance(result, tuple):
+                output_path, artificial_node_ids = result
+                logger.info(
+                    f"📄 Created: {len(artificial_node_ids)} artificial nodes for {len(station_coordinates)} stations"
+                )
+
+                # Use batch routing with calculate_multiple_isochrones
+                try:
+                    import fast_routing_py as routing
+
+                    network = routing.load_network(output_path)
+                    max_cost = 5  # 5 minutes
+
+                    # Use calculate_multiple_isochrones for all stations at once
+                    routing_results = network.calculate_multiple_isochrones(
+                        start_nodes=artificial_node_ids, max_cost=max_cost
+                    )
+
+                    # Process results
+                    for i, routing_result in enumerate(routing_results):
+                        if i < len(stations_data):
+                            station = stations_data[i]
+                            reachable = routing_result.reachable_nodes
+                            successful_routing += 1
+                            total_reachable += reachable
+
+                    # Cleanup
+                    if os.path.exists(output_path):
+                        os.unlink(output_path)
+
+                except Exception as e:
+                    logger.warning(f"❌ Batch routing failed: {e}")
+                    if os.path.exists(output_path):
+                        os.unlink(output_path)
+            else:
+                logger.warning("⚠️ Network processing failed")
+
+        except Exception as e:
+            logger.warning(f"❌ Station processing failed: {e}")
+
+    # Step 3: Results
+    success_rate = (
+        (successful_routing / len(stations_data) * 100) if stations_data else 0
+    )
+    logger.info(f"   MOTIS stations found: {len(stations_data)}")
+    logger.info(f"   Stations tested: {len(stations_data)}")
+    logger.info(f"   Successful routing: {successful_routing}")
+    logger.info(f"   Success rate: {success_rate:.1f}%")
+    logger.info(f"   Total reachable nodes: {total_reachable:,}")
+
+    # Assertions
+    assert len(stations_data) > 0, "Should find transit stations from MOTIS"
+    assert (
+        successful_routing > 0
+    ), "Should successfully route from at least some stations"
+    assert total_reachable > 0, "Should find reachable nodes"
+
+    logger.info("✅ Complete MOTIS + Rust workflow successful!")
+
+
+def test_routing_compatibility():
+    """Test that artificial nodes output can be loaded by the Rust routing library."""
+
+    # Test data path
+    test_file = Path("/app/packages/python/goatlib/tests/data/network/network.parquet")
+
+    if not test_file.exists():
+        logger.info(f"❌ Test file not found: {test_file}")
+        pytest.fail("Routing compatibility test failed: test file missing")
+
+    logger.info("🧪 Testing routing compatibility...")
+
+    try:
+        # Create some test points around Munich
+        origin = Coordinates(lat=48.1351, lon=11.5820)
+        start_points = [
+            Coordinates(lat=origin.lat + i * 0.001, lon=origin.lon + i * 0.001)
+            for i in range(10)  # Test with 10 points
+        ]
+
+        logger.info(f"📍 Testing with {len(start_points)} points around Munich")
+
+        with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
+            # Load network subset
+            subset_table = proc.load_network(center=origin, buffer_radius=1000.0)
+            logger.info(f"📊 Loaded network subset: {subset_table}")
+
+            # Create artificial nodes
+            logger.info("🔧 Creating artificial nodes...")
+            result = proc.create_artificial_nodes_for_points(
+                start_points, subset_table, search_radius_m=200.0
+            )
+
+            if isinstance(result, tuple):
+                output_path, artificial_node_ids = result
+                logger.info(" Created artificial nodes:")
+                logger.info(f"   📄 File: {output_path}")
+                logger.info(f"   🔢 Node IDs: {len(artificial_node_ids)} nodes")
+                logger.info(f"   🆔 First few IDs: {artificial_node_ids[:5]}")
+            else:
+                output_path = result
+                artificial_node_ids = None
+                logger.info(f"✅ Created network file: {output_path}")
+
+            # Verify file exists and has content
+            if not os.path.exists(output_path):
+                logger.info(f"❌ Output file not found: {output_path}")
+                pytest.fail("Routing compatibility test failed: output file missing")
+
+            file_size = os.path.getsize(output_path) / 1024  # KB
+            logger.info(f"📏 File size: {file_size:.1f} KB")
+
+            # Try to import the routing library
+            try:
+                import fast_routing_py as routing
+
+                # Test loading the network
+                logger.info("🔌 Loading network into routing library...")
+                network = routing.load_network(output_path)
+                logger.info("✅ Network loaded successfully into routing library!")
+
+                # If we have artificial node IDs, test routing
+                if artificial_node_ids and len(artificial_node_ids) > 0:
+                    logger.info("🧭 Testing routing calculation...")
+
+                    # Test with first artificial node
+                    start_node = artificial_node_ids[0]
+                    max_cost = 300  # 5 minutes in seconds
+                    logging.info(
+                        f"   Calculating isochrone from node {start_node} with max cost {max_cost}s..."
+                    )
+                    result = network.calculate_isochrone_multiple_times(
+                        start_node=start_node, time_thresholds=[max_cost]
+                    )
+
+                    if result and len(result) > 0:
+                        logger.info(
+                            f"   📈 Reachable nodes: {result[0].reachable_nodes}"
+                        )
+                        logger.info(f"   ⏱️  Max cost: {max_cost}s")
+                    else:
+                        logger.info("⚠️  Routing returned empty result")
+
+            except ImportError as e:
+                logger.info(f"⚠️  Could not import fast_routing_py: {e}")
+                pytest.fail(f"Routing compatibility test failed: {e}")
+
+            except Exception as e:
+                logger.info(f"❌ Error testing routing library: {e}")
+                pytest.fail(f"Routing compatibility test failed: {e}")
+
+    except Exception as e:
+        logger.info(f"❌ Test failed: {e}")
+        import traceback
+
+        traceback.logger.info_exc()
+        pytest.fail(f"Routing compatibility test failed: {e}")

From a515fc5e0ce8fb09665b4abb03cb5310f8eb0ba6 Mon Sep 17 00:00:00 2001
From: 96hoshi <marta.locascio@plan4better.de>
Date: Fri, 19 Dec 2025 15:37:02 +0000
Subject: [PATCH 10/11] fix: implemented get_isocrone in motis adaptor

---
 .../analysis/network/network_processor.py     | 147 +------------
 .../routing/adapters/motis/motis_adapter.py   | 201 ++++++++++++++----
 .../adapters/motis/motis_converters.py        |   1 -
 .../src/goatlib/routing/schemas/catchment.py  |  52 +++--
 .../routing/schemas/catchment_area_transit.py |   8 +-
 .../catchment/test_motis_get_isochrone.py     | 153 +++++++++++++
 .../catchment/test_routing_workflow.py        | 141 +++---------
 7 files changed, 388 insertions(+), 315 deletions(-)
 create mode 100644 packages/python/goatlib/tests/integration/routing/catchment/test_motis_get_isochrone.py

diff --git a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
index 04246342a..8b67cda16 100644
--- a/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
+++ b/packages/python/goatlib/src/goatlib/analysis/network/network_processor.py
@@ -34,7 +34,6 @@ def __init__(self, input_path: str) -> None:
         self._is_loaded = False
 
     # ==================== PUBLIC API METHODS ====================
-    # These are the main methods users will call
 
     @property
     def metadata(self) -> Metadata:
@@ -160,7 +159,7 @@ def load_network(
         except Exception as e:
             logger.debug(f"Could not create spatial index: {e}")
 
-        logger.debug(f"Loaded network subset in {elapsed:.3f}s")
+        logger.info(f"Network subset loaded: {elapsed:.3f}s")
 
         self._is_loaded = True
         return subset_table_name
@@ -315,21 +314,6 @@ def create_artificial_nodes_for_points(
         """
         Create ONE network file with artificial nodes for ALL points.
         Optimized version with batching and better memory management.
-
-        PERFORMANCE BOTTLENECK ANALYSIS:
-        1. **STARTUP OVERHEAD**: UUID generation and time calculations (~1ms)
-        2. **MEMORY SETUP**: Creating temporary tables and spatial indexes (~2-5ms)
-        3. **SPATIAL JOINS**: ST_DWithin operations for finding closest edges (~5-15ms)
-        4. **EDGE SPLITTING**: Complex geometry operations with ST_LineSubstring (~5-20ms)
-        5. **PARQUET EXPORT**: File I/O with compression and geometry serialization (~10-50ms)
-        6. **CLEANUP**: Dropping temporary tables (~1-2ms)
-
-        MAIN BOTTLENECKS FOR SMALL DATASETS (5 points):
-        - Fixed overhead from table creation/indexes dominates small workloads
-        - Geometry operations (ST_LineSubstring, ST_AsText) are expensive per operation
-        - Parquet export overhead is significant for small datasets
-        - Multiple SQL operations instead of single optimized query
-
         Args:
             stations: List of station coordinates
             subset_table: Pre-loaded network table name
@@ -340,22 +324,12 @@ def create_artificial_nodes_for_points(
         Returns:
             Tuple of (network_file_path, list_of_artificial_node_ids)
         """
-        logger.info(
-            f"Creating optimized network with artificial nodes for {len(points)} stations"
-        )
-
         if not points:
             return "", []
 
         artificial_node_start = time.time()
 
         try:
-            # OPTIMIZATION: Fast path for small datasets to avoid fixed overheads
-            if len(points) <= 10:
-                return self._create_artificial_nodes_fast_path(
-                    points, subset_table, search_radius_m, output_path
-                )
-
             # BOTTLENECK 1: File path generation and UUID creation (~0.5ms)
             # OPTIMIZATION: Could pre-generate paths or use simpler naming
             if output_path is None:
@@ -482,7 +456,6 @@ def create_artificial_nodes_for_points(
             edge_count = self.con.execute(
                 "SELECT COUNT(*) FROM temp_routing_network"
             ).fetchone()[0]
-            logger.info(f"Exporting {edge_count:,} edges to parquet")
 
             self.con.execute(f"""
                 COPY (
@@ -519,10 +492,10 @@ def create_artificial_nodes_for_points(
 
             # Enhanced performance logging
             logger.info(
-                f"Created optimized network: {len(points)} points → {edge_count:,} edges in {artificial_node_time:.3f}s"
+                f"Network with artificial nodes created: {len(points)} points → {edge_count:,} edges in {artificial_node_time:.3f}s"
             )
             logger.info(
-                f"Performance breakdown: processing={artificial_node_time-export_time:.3f}s, export={export_time:.3f}s"
+                f"Performance: processing={artificial_node_time-export_time:.3f}s, export={export_time:.3f}s"
             )
             logger.info(
                 f"Network file: {output_path} ({Path(output_path).stat().st_size / 1024 / 1024:.1f}MB)"
@@ -531,123 +504,12 @@ def create_artificial_nodes_for_points(
                 f"Node ID range: {base_node_id} to {base_node_id + len(points) - 1}"
             )
 
-            # PERFORMANCE SUMMARY FOR OPTIMIZATION:
-            # For 5 points, typical breakdown:
-            # - Setup (1-2ms): UUID, node IDs, table creation
-            # - Spatial operations (5-10ms): Spatial joins, distance calculations
-            # - Geometry operations (5-15ms): Edge splitting, line substrings
-            # - Export (10-40ms): File I/O, geometry to text conversion
-            #
-            # RECOMMENDED OPTIMIZATIONS:
-            # 1. Skip file export for small datasets, return in-memory data
-            # 2. Skip spatial indexing for < 50 points
-            # 3. Use simpler geometry operations or pre-computed lookup tables
-            # 4. Batch multiple calls to reuse setup overhead
-            # 5. Use faster serialization format or keep geometry binary
-
             return output_path, artificial_node_ids
 
         except Exception as e:
             logger.error(f"Failed to create single network: {e}")
             raise
 
-    def _create_artificial_nodes_fast_path(
-        self,
-        points: List[Coordinates],
-        subset_table: str,
-        search_radius_m: float,
-        output_path: Optional[str] = None,
-    ) -> Tuple[str, List[int]]:
-        """
-        Optimized fast path for small datasets (<= 10 points).
-        Avoids expensive table creation and spatial indexing overhead.
-        """
-        logger.debug(f"Using fast path for {len(points)} points")
-
-        if output_path is None:
-            output_path = f"{self._temp_dir}/routing_network_{int(time.time() * 1000) % 1000000}.parquet"
-
-        # Simple node ID generation
-        base_node_id = int(time.time() * 1000) % 1000000 + 1000000000
-        artificial_node_ids = [base_node_id + i for i in range(len(points))]
-
-        search_radius_deg = search_radius_m / 111320.0
-
-        # Build single optimized query without temporary tables
-        points_values = ", ".join(
-            [
-                f"({i}, {point.lat}, {point.lon}, {base_node_id + i})"
-                for i, point in enumerate(points)
-            ]
-        )
-
-        # Single query approach - much faster for small datasets
-        self.con.execute(f"""
-            COPY (
-                WITH points_data AS (
-                    SELECT station_idx, lat, lon, node_id,
-                           ST_MakePoint(lon, lat)::GEOMETRY as point_geom
-                    FROM (VALUES {points_values}) AS t(station_idx, lat, lon, node_id)
-                ),
-                closest_edges AS (
-                    SELECT DISTINCT ON (p.station_idx)
-                        p.station_idx, p.node_id,
-                        n.edge_id, n.source, n.target, n.length_m, n.geometry,
-                        ST_LineLocatePoint(n.geometry::GEOMETRY, p.point_geom) as frac
-                    FROM points_data p
-                    JOIN {subset_table} n ON ST_DWithin(
-                        n.geometry::GEOMETRY, 
-                        p.point_geom, 
-                        {search_radius_deg}
-                    )
-                    ORDER BY p.station_idx, ST_Distance(n.geometry::GEOMETRY, p.point_geom)
-                ),
-                all_edges AS (
-                    -- Original edges not being split
-                    SELECT 
-                        CAST(ROW_NUMBER() OVER (ORDER BY edge_id) + 1000000 AS INTEGER) as edge_id,
-                        CAST(source AS INTEGER) as source,
-                        CAST(target AS INTEGER) as target,
-                        length_m,
-                        ST_AsText(geometry) as geometry
-                    FROM {subset_table}
-                    WHERE edge_id NOT IN (SELECT edge_id FROM closest_edges)
-                    
-                    UNION ALL
-                    
-                    -- Split edge first part
-                    SELECT 
-                        CAST(ROW_NUMBER() OVER (ORDER BY edge_id, station_idx) + 2000000 AS INTEGER) as edge_id,
-                        source,
-                        node_id as target,
-                        GREATEST(0.1, length_m * GREATEST(0.01, frac)) as length_m,
-                        ST_AsText(ST_LineSubstring(geometry::GEOMETRY, 0.0, GREATEST(0.01, frac))) as geometry
-                    FROM closest_edges
-                    WHERE frac > 0.01
-                    
-                    UNION ALL
-                    
-                    -- Split edge second part  
-                    SELECT 
-                        CAST(ROW_NUMBER() OVER (ORDER BY edge_id, station_idx) + 3000000 AS INTEGER) as edge_id,
-                        node_id as source,
-                        target,
-                        GREATEST(0.1, length_m * GREATEST(0.01, 1.0 - frac)) as length_m,
-                        ST_AsText(ST_LineSubstring(geometry::GEOMETRY, GREATEST(0.01, frac), 1.0)) as geometry
-                    FROM closest_edges  
-                    WHERE frac < 0.99
-                )
-                SELECT edge_id, source, target, length_m, geometry
-                FROM all_edges
-                WHERE length_m > 0.1
-                ORDER BY edge_id
-            )
-            TO '{output_path}' (FORMAT PARQUET, COMPRESSION 'SNAPPY')
-        """)
-
-        logger.debug(f"Fast path completed: {output_path}")
-        return output_path, artificial_node_ids
-
     def interpolate_long_edges(
         self,
         max_edge_length: float,
@@ -772,7 +634,6 @@ def cleanup(self) -> None:
                 logger.warning(f"Failed to clean up temporary directory: {e}")
 
     # ==================== PRIVATE HELPER METHODS ====================
-    # Internal methods that support the public API
 
     def _setup_duckdb_extensions(self) -> None:
         """Configure DuckDB with optimized settings and error handling."""
@@ -784,7 +645,7 @@ def _setup_duckdb_extensions(self) -> None:
         settings = [
             "SET threads TO 4;",
             "SET enable_progress_bar=false;",
-            "SET memory_limit='2GB';",  # Reasonable memory limit
+            "SET memory_limit='2GB';",
         ]
 
         for ext in extensions + settings:
diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
index 6248c3309..b1a131291 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
@@ -1,22 +1,33 @@
 import asyncio
 import logging
+import time
+from collections import defaultdict
 from typing import Self
 
+import fast_routing_py as routing_rs
+
+from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
 from goatlib.routing.errors import ParsingError, RoutingError, ServiceError
 from goatlib.routing.interfaces.routing_service import RoutingService
 from goatlib.routing.schemas.ab_routing import (
     ABRoutingRequest,
     ABRoutingResponse,
 )
-from goatlib.routing.schemas.base import CatchmentAreaRoutingModePT
-from goatlib.routing.schemas.catchment import CatchmentRequest, CatchmentResponse
+from goatlib.routing.schemas.base import CatchmentAreaRoutingModePT, Coordinates
+from goatlib.routing.schemas.catchment import (
+    CatchmentRequest,
+    CatchmentResponse,
+    CutoffResult,
+)
 from goatlib.routing.schemas.catchment_area_transit import (
+    AccessEgressSettings,
     TransitCatchmentAreaRequest,
     TransitCatchmentAreaResponse,
 )
 
 from .motis_client import MotisServiceClient
 from .motis_converters import (
+    extract_bus_stations_for_buffering,
     parse_motis_one_to_all_response,
     parse_motis_response,
     translate_to_motis_one_to_all_request,
@@ -24,6 +35,7 @@
 )
 
 logger = logging.getLogger(__name__)
+PATH = "/app/packages/python/goatlib/tests/data/network/network.parquet"
 
 
 class MotisPlanApiAdapter(RoutingService):
@@ -43,6 +55,17 @@ def __init__(self: Self, motis_client: MotisServiceClient) -> None:
             motis_client: The MOTIS service client instance
         """
         self.motis_client = motis_client
+        self.network_path = PATH  # Set the default network path
+        self.transit_modes = [
+            CatchmentAreaRoutingModePT.bus,
+            CatchmentAreaRoutingModePT.tram,
+            CatchmentAreaRoutingModePT.subway,
+            CatchmentAreaRoutingModePT.rail,
+            CatchmentAreaRoutingModePT.ferry,
+            CatchmentAreaRoutingModePT.cable_car,
+            CatchmentAreaRoutingModePT.gondola,
+            CatchmentAreaRoutingModePT.funicular,
+        ]
 
     async def route(self: Self, request: ABRoutingRequest) -> ABRoutingResponse:
         """
@@ -88,43 +111,147 @@ async def route(self: Self, request: ABRoutingRequest) -> ABRoutingResponse:
             logger.error(f"Unexpected error during MOTIS routing: {e}")
             raise RoutingError("An unexpected internal error occurred") from e
 
-    async def get_isochrone(self: Self, request: CatchmentRequest) -> CatchmentResponse:
-        """
-        Execute an isochrone request using MOTIS one-to-all API.
+    async def get_isochrone(self, request: CatchmentRequest) -> CatchmentResponse:
+        test_file = PATH
 
-        Args:
-            request: Transit catchment area request
-
-        Returns:
-            TransitCatchmentAreaResponse with isochrone polygons
+        results: list[CutoffResult] = []
 
-        Raises:
-            ParsingError: If request/response format is invalid
-            ServiceError: If network/service connection fails
-            RoutingError: For unexpected errors
-        """
-        # Build MOTIS one-to-all request from our catchment request
-        # For simplicity, we assume all starting points use the same modes and cutoffs
-        # NOTE: Internally we accept and consider only the first point
-        # We let MOTIS handle first mile access internally
-        pt_reqeuest = TransitCatchmentAreaRequest(
-            starting_points=request.starting_points,
-            transit_modes=[
-                CatchmentAreaRoutingModePT.bus,
-                CatchmentAreaRoutingModePT.subway,
-                CatchmentAreaRoutingModePT.tram,
-                CatchmentAreaRoutingModePT.rail,
-            ],
-            cutoffs=request.cutoffs,
-        )
-
-        pt_response = await self._get_transit_catchment_area(pt_reqeuest)
-        # Convert TransitCatchmentAreaResponse to CatchmentResponse
-        catchment_response = CatchmentResponse(
-            pt_catchment=pt_response,
-            last_mile_catchment=None,  # TODO: integrate Rust catchment areas here
-        )
-        return catchment_response
+        try:
+            motis_request = TransitCatchmentAreaRequest(
+                starting_points=request.starting_points,
+                transit_modes=request.transit_modes,
+                cutoffs=request.cutoffs,
+                access_settings=AccessEgressSettings.create_walk_settings(),
+                egress_settings=AccessEgressSettings.create_walk_settings(),
+            )
+
+            motis_req = translate_to_motis_one_to_all_request(motis_request)
+            raw_response = await self.motis_client.one_to_all(motis_req)
+            raw_stations = extract_bus_stations_for_buffering(raw_response)
+
+            if not raw_stations:
+                return CatchmentResponse(
+                    results=[
+                        CutoffResult(
+                            cutoff_minutes=c,
+                            pt_stations_found=0,
+                            successful_routing=0,
+                            total_reachable_nodes=0,
+                            raw_response={},
+                        )
+                        for c in request.cutoffs
+                    ],
+                    metadata={"engine": "motis + rust"},
+                )
+            # ──────────────────────────────────────────────────────
+            # 2. Prepare stations + eligibility per cutoff
+            # ──────────────────────────────────────────────────────
+            stations: list[Coordinates] = []
+            station_times: list[int] = []
+
+            for s in raw_stations:
+                lon, lat = s["coordinates"]
+                t = int(s.get("duration_minutes", 0))
+
+                stations.append(Coordinates(lat=lat, lon=lon))
+                station_times.append(t)
+
+            # For each cutoff, which station indices are valid?
+            stations_per_cutoff: dict[int, list[int]] = defaultdict(list)
+
+            for idx, t in enumerate(station_times):
+                for cutoff in request.cutoffs:
+                    if t <= cutoff:
+                        stations_per_cutoff[cutoff].append(idx)
+
+            # ──────────────────────────────────────────────────────
+            # 3. Rust routing (single call, multiple cutoffs)
+            # ──────────────────────────────────────────────────────
+            network_processor_start = time.time()
+
+            with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
+                logger.info(
+                    f"Creating network subset around {motis_request.starting_points[0]}"
+                )
+
+                # Time network loading
+                subset = proc.load_network(
+                    center=request.starting_points[0],
+                    buffer_radius=1500.0,
+                )
+
+                # Time artificial nodes creation
+                output_path, node_ids = proc.create_artificial_nodes_for_points(
+                    stations, subset, search_radius_m=200.0
+                )
+
+                logger.info(
+                    f"Running Rust isochrone calculation for {len(stations)} stations"
+                )
+
+                # Time Rust network loading
+                rust_load_start = time.time()
+                network = routing_rs.load_network(output_path)
+                rust_load_time = time.time() - rust_load_start
+                logger.info(
+                    f"Rust routing_rs.load_network completed in {rust_load_time:.3f}s"
+                )
+
+                # Use the maximum egress time from the egress settings
+                # This is the configured maximum last-mile walking time
+                max_egress_time = motis_request.egress_settings.max_time
+                max_cutoff = max_egress_time * 60  # Convert to seconds for Rust
+
+                logger.info(
+                    f"Calculating last mile with max cutoff {max_cutoff} seconds"
+                )
+
+                # Time the main Rust isochrone calculation
+                rust_calc_start = time.time()
+                routing_results = network.calculate_multiple_isochrones(
+                    start_nodes=node_ids,
+                    max_cost=max_cutoff,
+                )
+                rust_calc_time = time.time() - rust_calc_start
+                logger.info(
+                    f"Rust calculate_multiple_isochrones completed in {rust_calc_time:.3f}s"
+                )
+            # ──────────────────────────────────────────────────────
+            # 4. Aggregate per cutoff
+            # ──────────────────────────────────────────────────────
+            results: list[CutoffResult] = []
+
+            for cutoff in request.cutoffs:
+                valid_station_indices = set(stations_per_cutoff[cutoff])
+
+                successful = 0
+                total_reachable = 0
+
+                for station_idx, iso in enumerate(routing_results):
+                    if station_idx in valid_station_indices:
+                        successful += 1
+                        total_reachable += iso.reachable_nodes
+
+                results.append(
+                    CutoffResult(
+                        cutoff_minutes=cutoff,
+                        pt_stations_found=len(valid_station_indices),
+                        successful_routing=successful,
+                        total_reachable_nodes=total_reachable,
+                        raw_response={"routing_summary": routing_results},
+                    )
+                )
+
+            return CatchmentResponse(
+                results=results,
+                metadata={
+                    "engine": "motis + rust",
+                    "stations_total": len(stations),
+                },
+            )
+
+        finally:
+            await self.motis_client.close()
 
     async def _get_transit_catchment_area(
         self: Self, request: TransitCatchmentAreaRequest
diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
index d961e1d95..1a279343d 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_converters.py
@@ -481,5 +481,4 @@ def extract_bus_stations_for_buffering(
         place_data["duration_minutes"] = loc.get(fields.travel_time, 0)
         stations.append(place_data)
 
-    logger.info(f"Extracted {len(stations)} valid bus stations for buffering")
     return stations
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py b/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
index 53a021614..15391b1ae 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/catchment.py
@@ -1,12 +1,13 @@
-from typing import List
+from typing import Any, Dict, List, Optional
 
+from core.schemas.catchment_area import CatchmentAreaRoutingModePT
 from pydantic import BaseModel, Field, field_validator
 
 from goatlib.routing.schemas.base import (
     CatchmentAreaType,
     Coordinates,
 )
-from goatlib.routing.schemas.catchment_area_transit import TransitCatchmentAreaResponse
+from goatlib.routing.schemas.catchment_area_transit import AccessEgressSettings
 
 
 class CatchmentRequest(BaseModel):
@@ -18,20 +19,35 @@ class CatchmentRequest(BaseModel):
         description="List of geographic Coordinates for catchment calculation starting points.",
         min_length=1,
     )
-
     cutoffs: List[float] = Field(
         ...,
         title="Cutoffs",
         description="List of cost thresholds for catchment area calculation (time in minutes or distance in meters).",
         min_length=1,
     )
-
     type: CatchmentAreaType = Field(
         ...,
         title="Area Type",
         description="The type of catchment area output to generate.",
     )
 
+    transit_modes: Optional[List[CatchmentAreaRoutingModePT]] = Field(
+        default=None,
+        title="Transit Modes",
+        description="List of public transit modes. If None, PT catchment is skipped.",
+    )
+    access_settings: Optional[AccessEgressSettings] = Field(
+        default_factory=AccessEgressSettings.create_walk_settings,
+        title="Access Settings",
+        description="Configuration for accessing the first transit stop. Defaults to walking.",
+    )
+    egress_settings: Optional[AccessEgressSettings] = Field(
+        # Default to a 15-minute walk. The caller can override this.
+        default_factory=AccessEgressSettings.create_walk_settings,
+        title="Egress Settings",
+        description="Configuration for the last-mile (egress) leg from transit stops or the origin. If None, the last-mile calculation is skipped.",
+    )
+
     @field_validator("cutoffs")
     @classmethod
     def validate_cutoffs(cls, v: List[float]) -> List[float]:
@@ -47,19 +63,25 @@ def validate_cutoffs(cls, v: List[float]) -> List[float]:
         return v
 
 
-class CatchmentResponse(BaseModel):
-    # TODO define a proper response schema
-    """Schema for catchment area responses."""
+class CutoffResult(BaseModel):
+    """Schema for the aggregated result of a single cutoff time."""
 
-    pt_catchment: TransitCatchmentAreaResponse = Field(
-        ...,
-        title="Public Transit Catchment Area Response",
-        description="Catchment area response from public transit calculation.",
+    cutoff_minutes: int
+    pt_stations_found: Optional[int] = None  # It might not be calculated
+    successful_routing: int
+    total_reachable_nodes: int
+    raw_response: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Raw response data from the routing engine",
     )
-    last_mile_catchment: dict | None = Field(
-        ...,
-        title="Last Mile Catchment Area Response",
-        description="Catchment area response from last mile calculation.",
+
+
+class CatchmentResponse(BaseModel):
+    """Schema for the final catchment area response."""
+
+    results: List[CutoffResult]
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict, description="Metadata about the calculation process."
     )
 
 
diff --git a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
index 6c4a97dc8..460c31aa7 100644
--- a/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
+++ b/packages/python/goatlib/src/goatlib/routing/schemas/catchment_area_transit.py
@@ -84,13 +84,13 @@ class TransitCatchmentAreaRequest(BaseModel):
         ge=0,
         le=routing_settings.transit.max_transfers,
     )
-    access_settings: AccessEgressSettings = Field(
-        default_factory=AccessEgressSettings.create_walk_settings,
+    access_settings: Optional[AccessEgressSettings] = Field(
+        default=AccessEgressSettings.create_walk_settings,
         title="Access Settings",
         description="Configuration for accessing transit stops.",
     )
-    egress_settings: AccessEgressSettings = Field(
-        default_factory=AccessEgressSettings.create_walk_settings,
+    egress_settings: Optional[AccessEgressSettings] = Field(
+        default=AccessEgressSettings.create_walk_settings,
         title="Egress Settings",
         description="Configuration for egressing from transit stops.",
     )
diff --git a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_get_isochrone.py b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_get_isochrone.py
new file mode 100644
index 000000000..07770c0be
--- /dev/null
+++ b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_get_isochrone.py
@@ -0,0 +1,153 @@
+# tests/adapters/test_motis_adapter_e2e.py
+
+import json
+import logging
+
+import pytest
+from goatlib.routing.adapters.motis.motis_adapter import (
+    MotisPlanApiAdapter,
+)
+from goatlib.routing.schemas.base import (
+    CatchmentAreaRoutingModePT,
+    CatchmentAreaType,
+    Coordinates,
+)
+from goatlib.routing.schemas.catchment import CatchmentRequest, CatchmentResponse
+from goatlib.routing.schemas.catchment_area_transit import (
+    AccessEgressSettings,
+)
+
+# Setup logger
+logger = logging.getLogger(__name__)
+
+# Assume your test data file is located here relative to your project root
+TEST_NETWORK_PATH = "packages/python/goatlib/tests/data/network/network.parquet"
+
+# --- End-to-End Test ---
+
+
+@pytest.mark.network  # Mark this test as requiring the network
+@pytest.mark.asyncio
+async def test_get_isochrone_live_e2e_chained_workflow(
+    motis_adapter_online: MotisPlanApiAdapter, mocker
+):
+    """
+    Tests the full chained workflow against a live MOTIS API and the real Rust engine.
+    This test will fail if the MOTIS API is unavailable or if the local network
+    data doesn't cover the requested area (Munich).
+    """
+    # Arrange
+    # We still spy on os.unlink to ensure cleanup happens correctly.
+    mock_unlink = mocker.patch("os.unlink")
+
+    # A realistic request for Munich, which should yield results
+    request = CatchmentRequest(
+        starting_points=[Coordinates(lat=48.1351, lon=11.5820)],  # Munich center
+        cutoffs=[15, 30],  # 15 and 30-minute isochrones
+        transit_modes=[
+            CatchmentAreaRoutingModePT.rail,
+            CatchmentAreaRoutingModePT.subway,
+            CatchmentAreaRoutingModePT.tram,
+        ],
+        access_settings=AccessEgressSettings.create_walk_settings(max_time=10),
+        egress_settings=AccessEgressSettings.create_walk_settings(max_time=15),
+        type=CatchmentAreaType.polygon,
+    )
+
+    # Act
+    logger.info("Sending live E2E request to MOTIS and local Rust engine...")
+    try:
+        response = await motis_adapter_online.get_isochrone(request)
+        # Close the client session after the test is done
+        await motis_adapter_online.motis_client.close()
+    except Exception as e:
+        await motis_adapter_online.motis_client.close()
+        pytest.fail(f"The live get_isochrone call failed with an exception: {e}")
+
+    logger.info(f"Received live response: {response.dict()}")
+
+    # Assert
+    # 1. Assertions on the response structure
+    assert isinstance(response, CatchmentResponse)
+    assert len(response.results) == 2, "Should have one result per cutoff"
+    assert (
+        mock_unlink.call_count > 0
+    ), "Temporary graph files should have been created and cleaned up"
+
+    # 2. Assertions on the 15-minute cutoff result
+    # These are "behavioral" assertions, not hardcoded numbers.
+    result_15_min = response.results[0]
+    assert result_15_min.cutoff_minutes == 15
+    assert result_15_min.pt_stations_found is not None
+    assert (
+        result_15_min.pt_stations_found > 0
+    ), "MOTIS should have found at least one station within 15 mins"
+    assert (
+        result_15_min.last_mile_walkshed_nodes > 0
+    ), "Rust engine should have found reachable nodes from the stations"
+
+    # 3. Assertions on the 30-minute cutoff result
+    result_30_min = response.results[1]
+    assert result_30_min.cutoff_minutes == 30
+    assert result_30_min.pt_stations_found is not None
+    assert (
+        result_30_min.pt_stations_found >= result_15_min.pt_stations_found
+    ), "30-min cutoff should find at least as many stations as 15-min"
+    assert (
+        result_30_min.last_mile_walkshed_nodes >= result_15_min.last_mile_walkshed_nodes
+    ), "30-min cutoff should cover a larger or equal area"
+    # We can be more confident that the 30-min result is strictly larger
+    assert result_30_min.pt_stations_found > 0
+    assert result_30_min.last_mile_walkshed_nodes > 0
+
+
+import json
+
+
+def get_all_attributes(obj):
+    """Get all attributes of an object."""
+    attrs = {}
+
+    # Get __dict__ attributes
+    if hasattr(obj, "__dict__"):
+        for k, v in obj.__dict__.items():
+            attrs[k] = v
+
+    # Get properties via getattr
+    for attr_name in dir(obj):
+        if not attr_name.startswith("_"):
+            try:
+                attr_value = getattr(obj, attr_name)
+                if not callable(attr_value) and attr_name not in attrs:
+                    attrs[attr_name] = attr_value
+            except:
+                attrs[attr_name] = "<Error accessing>"
+
+    return attrs
+
+
+@pytest.mark.asyncio
+@pytest.mark.network
+async def test_complete_motis_rust_workflow(
+    motis_adapter_online: MotisPlanApiAdapter,
+):
+    request = CatchmentRequest(
+        starting_points=[Coordinates(lat=48.1351, lon=11.5820)],  # Munich center
+        cutoffs=[15, 30],  # 15 and 30-minute isochrones
+        transit_modes=[
+            CatchmentAreaRoutingModePT.rail,
+            CatchmentAreaRoutingModePT.subway,
+            CatchmentAreaRoutingModePT.tram,
+        ],
+        access_settings=AccessEgressSettings.create_walk_settings(max_time=10),
+        egress_settings=AccessEgressSettings.create_walk_settings(max_time=15),
+        type=CatchmentAreaType.polygon,
+    )
+    response = await motis_adapter_online.get_isochrone(request)
+
+    assert response.results
+    r = response.results[0]
+
+    assert r.pt_stations_found > 0
+    assert r.successful_routing > 0
+    assert r.total_reachable_nodes > 0
diff --git a/packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py b/packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py
index a86122c22..ffaf82478 100644
--- a/packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py
+++ b/packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py
@@ -9,6 +9,10 @@
     CatchmentAreaRoutingModePT,
     Coordinates,
 )
+from goatlib.routing.schemas.catchment import (
+    CatchmentAreaType,
+    CatchmentRequest,
+)
 from goatlib.routing.schemas.catchment_area_transit import (
     AccessEgressSettings,
     TransitCatchmentAreaRequest,
@@ -17,20 +21,31 @@
 logger = logging.getLogger(__name__)
 
 
+# fixture of a standard catchment request in Munich
+@pytest.fixture
+def munich_catchment_request() -> CatchmentRequest:
+    """Create a standard Munich catchment area request."""
+    return CatchmentRequest(
+        starting_points=[
+            Coordinates(lat=48.1351, lon=11.5820)  # Munich center
+        ],
+        cutoffs=[15, 30, 45],  # 15, 30, and 45 minute isochrones
+        type=CatchmentAreaType.point,
+    )
+
+
 @pytest.mark.asyncio
 @pytest.mark.network
-async def test_complete_motis_rust_workflow():
+async def test_complete_motis_rust_workflow(munich_catchment_request: CatchmentRequest):
     """Complete MOTIS + Rust workflow using the correct adapter interface."""
 
-    logger.info("🚀 Starting complete MOTIS + Rust workflow...")
-
     # Test data path
     test_file = Path("/app/packages/python/goatlib/tests/data/network/network.parquet")
     if not test_file.exists():
+        logger.info(f"❌ Test file not found: {test_file}")
         pytest.skip(f"Test file not found: {test_file}")
 
     # Step 1: Use MOTIS adapter directly with the interface
-    logger.info("📡 Step 1: Getting transit catchment area from MOTIS...")
     center = Coordinates(lat=48.1351, lon=11.5820)  # Munich center
     motis_request = TransitCatchmentAreaRequest(
         starting_points=[center],  # Munich
@@ -55,14 +70,14 @@ async def test_complete_motis_rust_workflow():
 
         # Convert our request to MOTIS format and call directly
         motis_req = translate_to_motis_one_to_all_request(motis_request)
-        logger.info(f"🔄 MOTIS request: {motis_req}")
+        logger.info(f"MOTIS request: {motis_req}")
 
         raw_motis_response = await adapter.motis_client.one_to_all(motis_req)
-        logger.info("✅ MOTIS raw response received")
+        logger.info("MOTIS raw response received")
 
         # Extract stations from the raw response
         raw_stations = extract_bus_stations_for_buffering(raw_motis_response)
-        logger.info(f"📍 Extracted {len(raw_stations)} transit stations")
+        logger.info(f"Extracted {len(raw_stations)} transit stations")
 
         if not raw_stations:
             logger.info("❌ No stations found in MOTIS response")
@@ -87,6 +102,7 @@ async def test_complete_motis_rust_workflow():
                     "transit_time": station.get("duration_minutes", 0),
                 }
             )
+        # final_response = CatchmentResponse(last_mile_catchment=stations_data)
 
     except Exception as e:
         await adapter.motis_client.close()
@@ -96,8 +112,6 @@ async def test_complete_motis_rust_workflow():
     await adapter.motis_client.close()
 
     # Step 2: Process with Rust routing using the fast functions
-    logger.info("⚙️ Step 2: Testing Rust routing on transit stations...")
-
     successful_routing = 0
     total_reachable = 0
 
@@ -106,14 +120,13 @@ async def test_complete_motis_rust_workflow():
         subset_table = proc.load_network(
             center=center, buffer_radius=15000.0
         )  # 15km radius
-        logger.info(f"📊 Loaded network subset: {subset_table}")
+        logger.info(f"Loaded network subset: {subset_table}")
 
         # Process all stations in batch using calculate_multiple_isochrones
         station_coordinates = [
             Coordinates(lat=station["lat"], lon=station["lon"])
             for station in stations_data
         ]
-        logger.info(f"🔧 Processing {len(station_coordinates)} stations in batch...")
 
         try:
             # Create artificial nodes for all stations at once
@@ -124,7 +137,7 @@ async def test_complete_motis_rust_workflow():
             if isinstance(result, tuple):
                 output_path, artificial_node_ids = result
                 logger.info(
-                    f"📄 Created: {len(artificial_node_ids)} artificial nodes for {len(station_coordinates)} stations"
+                    f"Created: {len(artificial_node_ids)} artificial nodes for {len(station_coordinates)} stations"
                 )
 
                 # Use batch routing with calculate_multiple_isochrones
@@ -132,7 +145,7 @@ async def test_complete_motis_rust_workflow():
                     import fast_routing_py as routing
 
                     network = routing.load_network(output_path)
-                    max_cost = 5  # 5 minutes
+                    max_cost = 300  # 5 minutes in seconds
 
                     # Use calculate_multiple_isochrones for all stations at once
                     routing_results = network.calculate_multiple_isochrones(
@@ -166,7 +179,6 @@ async def test_complete_motis_rust_workflow():
         (successful_routing / len(stations_data) * 100) if stations_data else 0
     )
     logger.info(f"   MOTIS stations found: {len(stations_data)}")
-    logger.info(f"   Stations tested: {len(stations_data)}")
     logger.info(f"   Successful routing: {successful_routing}")
     logger.info(f"   Success rate: {success_rate:.1f}%")
     logger.info(f"   Total reachable nodes: {total_reachable:,}")
@@ -177,104 +189,3 @@ async def test_complete_motis_rust_workflow():
         successful_routing > 0
     ), "Should successfully route from at least some stations"
     assert total_reachable > 0, "Should find reachable nodes"
-
-    logger.info("✅ Complete MOTIS + Rust workflow successful!")
-
-
-def test_routing_compatibility():
-    """Test that artificial nodes output can be loaded by the Rust routing library."""
-
-    # Test data path
-    test_file = Path("/app/packages/python/goatlib/tests/data/network/network.parquet")
-
-    if not test_file.exists():
-        logger.info(f"❌ Test file not found: {test_file}")
-        pytest.fail("Routing compatibility test failed: test file missing")
-
-    logger.info("🧪 Testing routing compatibility...")
-
-    try:
-        # Create some test points around Munich
-        origin = Coordinates(lat=48.1351, lon=11.5820)
-        start_points = [
-            Coordinates(lat=origin.lat + i * 0.001, lon=origin.lon + i * 0.001)
-            for i in range(10)  # Test with 10 points
-        ]
-
-        logger.info(f"📍 Testing with {len(start_points)} points around Munich")
-
-        with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
-            # Load network subset
-            subset_table = proc.load_network(center=origin, buffer_radius=1000.0)
-            logger.info(f"📊 Loaded network subset: {subset_table}")
-
-            # Create artificial nodes
-            logger.info("🔧 Creating artificial nodes...")
-            result = proc.create_artificial_nodes_for_points(
-                start_points, subset_table, search_radius_m=200.0
-            )
-
-            if isinstance(result, tuple):
-                output_path, artificial_node_ids = result
-                logger.info(" Created artificial nodes:")
-                logger.info(f"   📄 File: {output_path}")
-                logger.info(f"   🔢 Node IDs: {len(artificial_node_ids)} nodes")
-                logger.info(f"   🆔 First few IDs: {artificial_node_ids[:5]}")
-            else:
-                output_path = result
-                artificial_node_ids = None
-                logger.info(f"✅ Created network file: {output_path}")
-
-            # Verify file exists and has content
-            if not os.path.exists(output_path):
-                logger.info(f"❌ Output file not found: {output_path}")
-                pytest.fail("Routing compatibility test failed: output file missing")
-
-            file_size = os.path.getsize(output_path) / 1024  # KB
-            logger.info(f"📏 File size: {file_size:.1f} KB")
-
-            # Try to import the routing library
-            try:
-                import fast_routing_py as routing
-
-                # Test loading the network
-                logger.info("🔌 Loading network into routing library...")
-                network = routing.load_network(output_path)
-                logger.info("✅ Network loaded successfully into routing library!")
-
-                # If we have artificial node IDs, test routing
-                if artificial_node_ids and len(artificial_node_ids) > 0:
-                    logger.info("🧭 Testing routing calculation...")
-
-                    # Test with first artificial node
-                    start_node = artificial_node_ids[0]
-                    max_cost = 300  # 5 minutes in seconds
-                    logging.info(
-                        f"   Calculating isochrone from node {start_node} with max cost {max_cost}s..."
-                    )
-                    result = network.calculate_isochrone_multiple_times(
-                        start_node=start_node, time_thresholds=[max_cost]
-                    )
-
-                    if result and len(result) > 0:
-                        logger.info(
-                            f"   📈 Reachable nodes: {result[0].reachable_nodes}"
-                        )
-                        logger.info(f"   ⏱️  Max cost: {max_cost}s")
-                    else:
-                        logger.info("⚠️  Routing returned empty result")
-
-            except ImportError as e:
-                logger.info(f"⚠️  Could not import fast_routing_py: {e}")
-                pytest.fail(f"Routing compatibility test failed: {e}")
-
-            except Exception as e:
-                logger.info(f"❌ Error testing routing library: {e}")
-                pytest.fail(f"Routing compatibility test failed: {e}")
-
-    except Exception as e:
-        logger.info(f"❌ Test failed: {e}")
-        import traceback
-
-        traceback.logger.info_exc()
-        pytest.fail(f"Routing compatibility test failed: {e}")

From 838c02ec88f7b2a7f12e90e92dedf2c86b4a0a93 Mon Sep 17 00:00:00 2001
From: 96hoshi <marta.locascio@plan4better.de>
Date: Fri, 19 Dec 2025 16:41:03 +0000
Subject: [PATCH 11/11] refactor: reordered test in proper folder and proper
 file, with proper name

---
 .../routing/adapters/motis/motis_adapter.py   |  29 +-
 .../integration/network/test_catchment.py     | 266 ------------
 .../test_motis_adapter_edge_cases.py          |   0
 .../test_motis_adapter_errors.py              |   0
 .../adapter/test_motis_adapter_one_to_all.py} | 331 +++++++++++----
 .../test_motis_adapter_online.py              |   0
 .../test_motis_adapter_one_to_all.py          | 210 ----------
 .../catchment/test_motis_buffered_station.py  |  42 +-
 .../catchment/test_motis_get_isochrone.py     | 383 +++++++++++++-----
 .../catchment/test_routing_workflow.py        | 191 ---------
 .../catchment}/test_rust_network_analysis.py  |   0
 ..._routing_schemas.py => test_ab_schemas.py} |  49 ++-
 ...te_validation.py => test_ab_validation.py} |   6 +
 .../tests/unit/routing/test_base_schemas.py   |  55 ---
 ...nsit.py => test_catchment_area_schemas.py} |   0
 15 files changed, 619 insertions(+), 943 deletions(-)
 delete mode 100644 packages/python/goatlib/tests/integration/network/test_catchment.py
 rename packages/python/goatlib/tests/integration/routing/{ab => adapter}/test_motis_adapter_edge_cases.py (100%)
 rename packages/python/goatlib/tests/integration/routing/{ab => adapter}/test_motis_adapter_errors.py (100%)
 rename packages/python/goatlib/tests/{unit/routing/test_motis_one_to_all.py => integration/routing/adapter/test_motis_adapter_one_to_all.py} (58%)
 rename packages/python/goatlib/tests/integration/routing/{ab => adapter}/test_motis_adapter_online.py (100%)
 delete mode 100644 packages/python/goatlib/tests/integration/routing/catchment/test_motis_adapter_one_to_all.py
 delete mode 100644 packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py
 rename packages/python/goatlib/tests/integration/{network => routing/catchment}/test_rust_network_analysis.py (100%)
 rename packages/python/goatlib/tests/unit/routing/{test_ab_routing_schemas.py => test_ab_schemas.py} (79%)
 rename packages/python/goatlib/tests/unit/routing/{test_route_validation.py => test_ab_validation.py} (95%)
 delete mode 100644 packages/python/goatlib/tests/unit/routing/test_base_schemas.py
 rename packages/python/goatlib/tests/unit/routing/{test_catchment_area_transit.py => test_catchment_area_schemas.py} (100%)

diff --git a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
index b1a131291..e892b0469 100644
--- a/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
+++ b/packages/python/goatlib/src/goatlib/routing/adapters/motis/motis_adapter.py
@@ -34,8 +34,9 @@
     translate_to_motis_request,
 )
 
-logger = logging.getLogger(__name__)
+# Momentary fix for test data path
 PATH = "/app/packages/python/goatlib/tests/data/network/network.parquet"
+logger = logging.getLogger(__name__)
 
 
 class MotisPlanApiAdapter(RoutingService):
@@ -55,17 +56,6 @@ def __init__(self: Self, motis_client: MotisServiceClient) -> None:
             motis_client: The MOTIS service client instance
         """
         self.motis_client = motis_client
-        self.network_path = PATH  # Set the default network path
-        self.transit_modes = [
-            CatchmentAreaRoutingModePT.bus,
-            CatchmentAreaRoutingModePT.tram,
-            CatchmentAreaRoutingModePT.subway,
-            CatchmentAreaRoutingModePT.rail,
-            CatchmentAreaRoutingModePT.ferry,
-            CatchmentAreaRoutingModePT.cable_car,
-            CatchmentAreaRoutingModePT.gondola,
-            CatchmentAreaRoutingModePT.funicular,
-        ]
 
     async def route(self: Self, request: ABRoutingRequest) -> ABRoutingResponse:
         """
@@ -112,8 +102,6 @@ async def route(self: Self, request: ABRoutingRequest) -> ABRoutingResponse:
             raise RoutingError("An unexpected internal error occurred") from e
 
     async def get_isochrone(self, request: CatchmentRequest) -> CatchmentResponse:
-        test_file = PATH
-
         results: list[CutoffResult] = []
 
         try:
@@ -167,9 +155,8 @@ async def get_isochrone(self, request: CatchmentRequest) -> CatchmentResponse:
             # ──────────────────────────────────────────────────────
             # 3. Rust routing (single call, multiple cutoffs)
             # ──────────────────────────────────────────────────────
-            network_processor_start = time.time()
 
-            with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
+            with InMemoryNetworkProcessor(input_path=str(PATH)) as proc:
                 logger.info(
                     f"Creating network subset around {motis_request.starting_points[0]}"
                 )
@@ -305,16 +292,8 @@ async def _get_transit_catchment_area(
 def create_motis_adapter(
     base_url: str = "https://api.transitous.org",
 ) -> MotisPlanApiAdapter:
-    """
-    Convenience function to create a MOTIS adapter instance.
+    """Factory function to create a MOTISPlanApiAdapter with a configured client."""
 
-    Args:
-        base_url: Base URL for the MOTIS API
-
-    Returns:
-        Configured MotisPlanApiAdapter instance
-
-    """
     motis_client = MotisServiceClient(
         base_url=base_url,
     )
diff --git a/packages/python/goatlib/tests/integration/network/test_catchment.py b/packages/python/goatlib/tests/integration/network/test_catchment.py
deleted file mode 100644
index 30bd2a986..000000000
--- a/packages/python/goatlib/tests/integration/network/test_catchment.py
+++ /dev/null
@@ -1,266 +0,0 @@
-import logging
-import os
-import time
-from pathlib import Path
-
-import fast_routing_py as routing
-from goatlib.analysis.network.network_processor import (
-    InMemoryNetworkProcessor,
-)
-from goatlib.routing.schemas.base import Coordinates
-
-logger = logging.getLogger(__name__)
-
-example_request = {
-    "starting_points": [{"lat": 48.1351, "lon": 11.5820}],  # Munich central
-    "cutoffs": [10, 20, 30],
-    "type": "point",
-}
-
-
-def test_catchment_workflow(network_file: Path):
-    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
-        # Use the new optimized method that combines all preprocessing
-        start_coords = Coordinates(lat=48.1351, lon=11.5820)
-
-        # Define cutoffs first to ensure network preparation covers the max cutoff
-        cutoffs_minutes = [10, 20, 30]
-        max_cutoff = max(cutoffs_minutes)
-
-        parquet_path, start_node_id = proc.prepare_routing_network(
-            start_point=start_coords,
-            buffer_radius=1000.0,
-            travel_time_minutes=max_cutoff,  # Use max cutoff for network preparation
-            speed_kmh=5.0,
-        )
-
-        # Load network with fast_routing_py and calculate isochrone
-        network = routing.load_network(parquet_path)
-
-        # Calculate isochrones for the requested cutoffs (convert minutes to seconds)
-        cutoffs_seconds = [c * 60 for c in cutoffs_minutes]
-        results = network.calculate_isochrone_multiple_times(
-            start_node=start_node_id, time_thresholds=cutoffs_seconds
-        )
-
-        assert len(results) == 3  # One result per cutoff
-        for i, result in enumerate(results):
-            assert result.reachable_nodes > 0
-            logger.info(
-                f"Cutoff {cutoffs_minutes[i]} min: {result.reachable_nodes} reachable nodes"
-            )
-
-
-def test_optimized_catchment_benchmark(network_file: Path):
-    """
-    Benchmark the optimized catchment workflow with split-edge approach.
-    Tests realistic scenarios with performance targets.
-    """
-    logger.info("=== OPTIMIZED CATCHMENT BENCHMARK ===")
-
-    # Test configurations: [buffer_radius, travel_time, speed, expected_time_ms]
-    test_configs = [
-        (200, 2.0, 12.0, 85),  # Ultra-minimal for speed
-        (400, 3.0, 12.0, 95),  # Small catchment
-        (800, 5.0, 12.0, 110),  # Medium catchment
-    ]
-
-    results = []
-
-    for buffer_radius, travel_time, speed, expected_max_ms in test_configs:
-        logger.info(
-            f"\n--- Testing {buffer_radius}m buffer, {travel_time}min travel time ---"
-        )
-
-        # Run 3 iterations for stable timing
-        times = []
-        for run in range(3):
-            with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
-                start_coords = Coordinates(lat=48.1351, lon=11.5820)
-
-                # Time the full preparation
-                t1 = time.time()
-                parquet_path, start_node_id = proc.prepare_routing_network(
-                    start_point=start_coords,
-                    buffer_radius=buffer_radius,
-                    travel_time_minutes=travel_time,
-                    speed_kmh=speed,
-                )
-                t2 = time.time()
-                prep_time = (t2 - t1) * 1000
-
-                # Quick routing test
-                t3 = time.time()
-                network = routing.load_network(parquet_path)
-                cutoffs_seconds = [5 * 60, 10 * 60]  # 5min, 10min
-                isochrones = network.calculate_isochrone_multiple_times(
-                    start_node=start_node_id, time_thresholds=cutoffs_seconds
-                )
-                t4 = time.time()
-                routing_time = (t4 - t3) * 1000
-
-                total_time = prep_time + routing_time
-                times.append(
-                    {
-                        "prep": prep_time,
-                        "routing": routing_time,
-                        "total": total_time,
-                        "nodes": sum(r.reachable_nodes for r in isochrones),
-                    }
-                )
-
-                # Cleanup
-                if os.path.exists(parquet_path):
-                    os.unlink(parquet_path)
-
-        # Calculate averages
-        avg_prep = sum(t["prep"] for t in times) / len(times)
-        avg_routing = sum(t["routing"] for t in times) / len(times)
-        avg_total = sum(t["total"] for t in times) / len(times)
-        avg_nodes = sum(t["nodes"] for t in times) / len(times)
-
-        # Log results
-        prep_status = "✓" if avg_prep < expected_max_ms else "✗"
-        total_status = "✓" if avg_total < expected_max_ms + 50 else "✗"
-
-        logger.info(f"  Network prep: {avg_prep:.1f}ms {prep_status}")
-        logger.info(f"  Routing calc: {avg_routing:.1f}ms")
-        logger.info(f"  Total time:   {avg_total:.1f}ms {total_status}")
-        logger.info(f"  Avg nodes:    {avg_nodes:.0f}")
-
-        results.append(
-            {
-                "config": f"{buffer_radius}m_{travel_time}min",
-                "prep_time": avg_prep,
-                "routing_time": avg_routing,
-                "total_time": avg_total,
-                "target_prep": expected_max_ms,
-                "nodes": avg_nodes,
-            }
-        )
-
-    # Summary analysis
-    best_prep = min(r["prep_time"] for r in results)
-    best_total = min(r["total_time"] for r in results)
-
-    logger.info(f"Best prep time: {best_prep:.1f}ms")
-    logger.info(f"Best total time: {best_total:.1f}ms")
-
-    # Performance assertions
-    assert best_prep < 100, f"Best prep time {best_prep:.1f}ms should be under 100ms"
-    assert best_total < 150, f"Best total time {best_total:.1f}ms should be under 150ms"
-    assert all(
-        r["nodes"] > 100 for r in results
-    ), "All configs should find substantial nodes"
-
-    logger.info("✓ Optimized catchment benchmark PASSED")
-
-
-def test_split_edge_accuracy_benchmark(network_file: Path):
-    """
-    Test the accuracy improvements of the optimized routing network preparation.
-    """
-    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
-        start_coords = Coordinates(lat=48.1351, lon=11.5820)
-
-        # Test optimized routing network preparation
-        t1 = time.time()
-        parquet_path, start_node_id = proc.prepare_routing_network(
-            start_point=start_coords, buffer_radius=500.0
-        )
-        t2 = time.time()
-
-        prep_time = (t2 - t1) * 1000
-
-        logger.info(f"Optimized routing prep: {prep_time:.1f}ms")
-        logger.info(f"  Start node ID: {start_node_id}")
-        logger.info(f"  Output file: {parquet_path}")
-
-        # Load the result to verify network quality
-        import duckdb
-
-        con = duckdb.connect(":memory:")
-        con.execute("INSTALL spatial; LOAD spatial;")
-
-        # Get network statistics
-        network_info = con.execute(f"""
-            SELECT 
-                COUNT(*) as edge_count,
-                COUNT(DISTINCT source) as unique_sources,
-                COUNT(DISTINCT target) as unique_targets,
-                AVG(length_m) as avg_length
-            FROM read_parquet('{parquet_path}')
-        """).fetchone()
-
-        edge_count = network_info[0]
-        avg_length = network_info[3]
-
-        logger.info(f"  Network edges: {edge_count}")
-        logger.info(f"  Avg edge length: {avg_length:.1f}m")
-
-        # Verify the start node exists in the network
-        start_node_exists = con.execute(f"""
-            SELECT COUNT(*) FROM read_parquet('{parquet_path}')
-            WHERE source = {start_node_id} OR target = {start_node_id}
-        """).fetchone()[0]
-
-        logger.info(f"  Start node connectivity: {start_node_exists} edges")
-
-        # Clean up
-        import os
-
-        if os.path.exists(parquet_path):
-            os.unlink(parquet_path)
-        con.close()
-
-        # Assertions for quality
-        assert edge_count > 100, "Network should have substantial edges"
-        assert start_node_exists > 0, "Start node should be connected to the network"
-        assert avg_length > 0, "Edges should have positive length"
-        assert (
-            prep_time < 150
-        ), f"Preparation took {prep_time:.1f}ms, should be under 150ms"
-
-        logger.info("✓ Optimized routing network accuracy benchmark PASSED")
-
-
-# add a test to try calculate_multiple_isochrones on the rust_network_analysis module
-def test_rust_network_multiple_isochrones(network_file: Path):
-    """
-    Test the Rust network analysis library's ability to calculate multiple isochrones.
-    """
-
-    # Use InMemoryNetworkProcessor to prepare a properly formatted network for Rust
-    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
-        start_coords = Coordinates(lat=48.1351, lon=11.5820)
-
-        # Prepare the network in the format expected by the Rust library
-        parquet_path, start_node_id = proc.prepare_routing_network(
-            start_point=start_coords,
-            buffer_radius=1000.0,
-            travel_time_minutes=20.0,
-            speed_kmh=5.0,
-        )
-
-        # Load the network using the Rust library
-        network = routing.load_network(parquet_path)
-
-    # Define multiple cutoffs in seconds
-    cutoffs_seconds = [300, 600, 900]  # 5min, 10min, 15min
-
-    # Calculate multiple isochrones
-    results = network.calculate_isochrone_multiple_times(
-        start_node=start_node_id, time_thresholds=cutoffs_seconds
-    )
-
-    assert len(results) == len(cutoffs_seconds), "Should return results for all cutoffs"
-
-    for i, result in enumerate(results):
-        assert (
-            result.reachable_nodes > 0
-        ), f"Isochrone for cutoff {cutoffs_seconds[i]}s should have reachable nodes"
-        logger.info(
-            f"Cutoff {cutoffs_seconds[i]//60} min: {result.reachable_nodes} reachable nodes"
-        )
-
-    logger.info("✓ Rust network multiple isochrones test PASSED")
diff --git a/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_edge_cases.py b/packages/python/goatlib/tests/integration/routing/adapter/test_motis_adapter_edge_cases.py
similarity index 100%
rename from packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_edge_cases.py
rename to packages/python/goatlib/tests/integration/routing/adapter/test_motis_adapter_edge_cases.py
diff --git a/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_errors.py b/packages/python/goatlib/tests/integration/routing/adapter/test_motis_adapter_errors.py
similarity index 100%
rename from packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_errors.py
rename to packages/python/goatlib/tests/integration/routing/adapter/test_motis_adapter_errors.py
diff --git a/packages/python/goatlib/tests/unit/routing/test_motis_one_to_all.py b/packages/python/goatlib/tests/integration/routing/adapter/test_motis_adapter_one_to_all.py
similarity index 58%
rename from packages/python/goatlib/tests/unit/routing/test_motis_one_to_all.py
rename to packages/python/goatlib/tests/integration/routing/adapter/test_motis_adapter_one_to_all.py
index 558df39cc..31fa56691 100644
--- a/packages/python/goatlib/tests/unit/routing/test_motis_one_to_all.py
+++ b/packages/python/goatlib/tests/integration/routing/adapter/test_motis_adapter_one_to_all.py
@@ -9,7 +9,11 @@
     parse_motis_one_to_all_response,
     translate_to_motis_one_to_all_request,
 )
-from goatlib.routing.schemas.base import CatchmentAreaRoutingModePT
+from goatlib.routing.schemas.base import (
+    AccessEgressMode,
+    CatchmentAreaRoutingModePT,
+    Coordinates,
+)
 from goatlib.routing.schemas.catchment_area_transit import (
     AccessEgressSettings,
     TransitCatchmentAreaRequest,
@@ -18,33 +22,76 @@
 logger = logging.getLogger(__name__)
 
 
+# ============================================================================
+# FIXTURES
+# ============================================================================
+
+
+@pytest.fixture
+def motis_adapter_online():
+    """Fixture providing a MOTIS adapter instance for online tests."""
+    adapter = create_motis_adapter()
+    yield adapter
+    # Cleanup is handled in tests using async context
+
+
+@pytest.fixture
+def simple_berlin_request():
+    """Simple Berlin request for basic integration tests."""
+    return TransitCatchmentAreaRequest(
+        starting_points=[Coordinates(lat=52.520008, lon=13.404954)],
+        cutoffs=[15, 30],
+        transit_modes=[CatchmentAreaRoutingModePT.bus, CatchmentAreaRoutingModePT.tram],
+        access_settings=AccessEgressSettings.create_walk_settings(max_time=10),
+        egress_settings=AccessEgressSettings.create_walk_settings(max_time=10),
+    )
+
+
+@pytest.fixture
+def munich_request():
+    """Munich request for testing different scenarios."""
+    return TransitCatchmentAreaRequest(
+        starting_points=[Coordinates(lat=48.137154, lon=11.576124)],
+        cutoffs=[10, 20, 30],
+        transit_modes=[CatchmentAreaRoutingModePT.bus, CatchmentAreaRoutingModePT.tram],
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
+    )
+
+
+@pytest.fixture
+def plausibility_tester():
+    """Fixture providing a MotisOneToAllPlausibilityTester instance."""
+    return MotisOneToAllPlausibilityTester()
+
+
+# ============================================================================
+# PLAUSIBILITY TESTER CLASS
+# ============================================================================
+
+
 class MotisOneToAllPlausibilityTester:
     """Comprehensive plausibility tester for MOTIS one-to-all responses."""
 
     def __init__(self):
         self.tolerance_meters = 1000  # 1km tolerance for location validation
-        self.max_reasonable_travel_time = (
-            120  # 2 hours max reasonable travel time (in minutes)
-        )
+        self.max_reasonable_travel_time = 120  # 2 hours max (minutes)
         self.min_locations_expected = 5  # Minimum locations we expect to reach
 
     def validate_raw_motis_response(self, motis_data: Dict[str, Any]) -> List[str]:
         """Validate the raw MOTIS response structure and content."""
         issues = []
 
-        # Check basic structure
         if not isinstance(motis_data, dict):
             issues.append("MOTIS response is not a dictionary")
             return issues
 
-        # Check for expected top-level fields
         if "all" not in motis_data:
             issues.append("Missing 'all' field in MOTIS response")
             return issues
 
         reachable_locations = motis_data.get("all", [])
 
-        # Validate reachable locations structure
         if not isinstance(reachable_locations, list):
             issues.append("'all' field is not a list")
             return issues
@@ -54,7 +101,6 @@ def validate_raw_motis_response(self, motis_data: Dict[str, Any]) -> List[str]:
                 f"Too few reachable locations: {len(reachable_locations)} < {self.min_locations_expected}"
             )
 
-        # Validate individual location entries
         for idx, location in enumerate(reachable_locations):
             location_issues = self._validate_location_entry(location, idx)
             issues.extend(location_issues)
@@ -66,19 +112,16 @@ def _validate_location_entry(self, location: Dict[str, Any], idx: int) -> List[s
         issues = []
         prefix = f"Location {idx}:"
 
-        # Check required fields
         required_fields = ["place", "duration"]
         for field in required_fields:
             if field not in location:
                 issues.append(f"{prefix} Missing required field '{field}'")
                 continue
 
-        # Duration check (simplified - MOTIS is reliable)
         duration = location.get("duration", 0)
-        if duration > self.max_reasonable_travel_time:  # Duration is already in minutes
+        if duration > self.max_reasonable_travel_time:
             issues.append(f"{prefix} Unreasonably long travel time: {duration} min")
 
-        # Validate place information
         place = location.get("place", {})
         if not isinstance(place, dict):
             issues.append(f"{prefix} 'place' field is not a dictionary")
@@ -94,13 +137,11 @@ def _validate_place_data(self, place: Dict[str, Any], idx: int) -> List[str]:
         issues = []
         prefix = f"Location {idx} place:"
 
-        # Check for coordinate fields
         if "lon" not in place and "lng" not in place:
             issues.append(f"{prefix} Missing longitude field (lon/lng)")
         if "lat" not in place:
             issues.append(f"{prefix} Missing latitude field")
 
-        # Get longitude (handle both lon and lng)
         lon = place.get("lon", place.get("lng"))
         lat = place.get("lat")
 
@@ -125,7 +166,6 @@ async def run_comprehensive_test(self) -> Dict[str, Any]:
         adapter = create_motis_adapter()
 
         try:
-            # Create test request
             request = TransitCatchmentAreaRequest(
                 starting_points=[{"lat": 48.1351, "lon": 11.5820}],
                 transit_modes=[
@@ -137,14 +177,10 @@ async def run_comprehensive_test(self) -> Dict[str, Any]:
                 egress_settings=AccessEgressSettings.create_walk_settings(),
             )
 
-            # Get MOTIS response
             motis_request_data = translate_to_motis_one_to_all_request(request)
             motis_response = await adapter.motis_client.one_to_all(motis_request_data)
 
-            # Validate raw response
             raw_issues = self.validate_raw_motis_response(motis_response)
-
-            # Parse response and validate
             parsed_response = parse_motis_one_to_all_response(motis_response, request)
             parsed_issues = []
 
@@ -155,13 +191,11 @@ async def run_comprehensive_test(self) -> Dict[str, Any]:
             elif len(parsed_response.polygons) == 0:
                 parsed_issues.append("No polygons generated from response")
 
-            # Gather statistics
             reachable_locations = motis_response.get("all", [])
             travel_times = [loc.get("duration", 0) for loc in reachable_locations]
 
-            # Test adapter integration
             try:
-                adapter_response = await adapter.get_transit_catchment_area(request)
+                adapter_response = await adapter._get_transit_catchment_area(request)
                 adapter_polygon_count = (
                     len(adapter_response.polygons) if adapter_response else 0
                 )
@@ -173,7 +207,6 @@ async def run_comprehensive_test(self) -> Dict[str, Any]:
                 adapter_polygon_count = 0
                 direct_polygon_count = 0
 
-            # Compile results
             results = {
                 "timestamp": datetime.now().isoformat(),
                 "test_location": "Munich, Germany",
@@ -228,28 +261,176 @@ async def run_comprehensive_test(self) -> Dict[str, Any]:
                 await adapter.motis_client.close()
 
 
-@pytest.fixture
-def plausibility_tester():
-    """Fixture providing a MotisOneToAllPlausibilityTester instance."""
-    return MotisOneToAllPlausibilityTester()
+# ============================================================================
+# BASIC FUNCTIONALITY TESTS
+# ============================================================================
 
 
-@pytest.fixture
-def sample_request():
-    """Fixture providing a sample transit catchment area request."""
-    return TransitCatchmentAreaRequest(
-        starting_points=[
-            {"lat": 48.1351, "lon": 11.5820}  # Munich city center
-        ],
+@pytest.mark.network
+async def test_basic_one_to_all_success(motis_adapter_online, simple_berlin_request):
+    """Test basic one-to-all functionality returns valid catchment areas."""
+    async with motis_adapter_online.motis_client:
+        response = await motis_adapter_online._get_transit_catchment_area(
+            simple_berlin_request
+        )
+
+    assert response is not None
+    assert len(response.polygons) == len(simple_berlin_request.cutoffs)
+    assert response.metadata.get("total_locations", 0) > 0
+    assert response.metadata.get("source") == "motis_one_to_all"
+
+    for polygon in response.polygons:
+        assert polygon.travel_time in simple_berlin_request.cutoffs
+        assert hasattr(polygon, "points")
+        assert isinstance(polygon.points, list)
+
+        if polygon.geometry is not None:
+            assert polygon.geometry["type"] == "Polygon"
+            assert "coordinates" in polygon.geometry
+        elif polygon.points:
+            polygon.set_geometry_from_points()
+            assert polygon.geometry["type"] == "Polygon"
+            assert "coordinates" in polygon.geometry
+
+
+async def test_multiple_cutoffs(motis_adapter_online, munich_request):
+    """Test that multiple travel time cutoffs generate correct polygons."""
+    async with motis_adapter_online.motis_client:
+        response = await motis_adapter_online._get_transit_catchment_area(
+            munich_request
+        )
+
+    assert len(response.polygons) == len(munich_request.cutoffs)
+    travel_times = [p.travel_time for p in response.polygons]
+    assert sorted(travel_times) == sorted(munich_request.cutoffs)
+
+
+@pytest.mark.network
+async def test_different_transit_modes(motis_adapter_online):
+    """Test different combinations of transit modes."""
+    rail_only_request = TransitCatchmentAreaRequest(
+        starting_points=[Coordinates(lat=52.5200, lon=13.4050)],
+        transit_modes=[CatchmentAreaRoutingModePT.rail],
+        cutoffs=[20],
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
+    )
+
+    async with motis_adapter_online.motis_client:
+        response = await motis_adapter_online._get_transit_catchment_area(
+            rail_only_request
+        )
+
+    assert len(response.polygons) == 1
+
+
+async def test_single_cutoff(motis_adapter_online):
+    """Test with a single travel time cutoff."""
+    single_cutoff_request = TransitCatchmentAreaRequest(
+        starting_points=[Coordinates(lat=48.1351, lon=11.5820)],
         transit_modes=[
-            CatchmentAreaRoutingModePT.bus,
             CatchmentAreaRoutingModePT.subway,
+            CatchmentAreaRoutingModePT.tram,
         ],
-        cutoffs=[10, 20, 30],
+        cutoffs=[20],
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
+    )
+
+    async with motis_adapter_online.motis_client:
+        response = await motis_adapter_online._get_transit_catchment_area(
+            single_cutoff_request
+        )
+
+    assert len(response.polygons) == 1
+    assert response.polygons[0].travel_time == 20
+
+
+async def test_geometry_structure(motis_adapter_online, simple_berlin_request):
+    """Test that returned geometry has correct GeoJSON structure."""
+    async with motis_adapter_online.motis_client:
+        response = await motis_adapter_online._get_transit_catchment_area(
+            simple_berlin_request
+        )
+
+    for polygon in response.polygons:
+        assert hasattr(polygon, "points")
+        assert isinstance(polygon.points, list)
+
+        if polygon.geometry is None:
+            polygon.set_geometry_from_points()
+
+        if polygon.points and polygon.geometry:
+            assert polygon.geometry["type"] == "Polygon"
+            assert "coordinates" in polygon.geometry
+            if polygon.geometry["coordinates"]:
+                coord_ring = polygon.geometry["coordinates"][0]
+                assert len(coord_ring) >= 4
+                assert len(coord_ring[0]) == 2
+                assert coord_ring[0] == coord_ring[-1]
+
+
+async def test_bike_access_egress(motis_adapter_online):
+    """Test catchment area with bicycle access and egress modes."""
+    bike_request = TransitCatchmentAreaRequest(
+        starting_points=[Coordinates(lat=52.5200, lon=13.4050)],
+        transit_modes=[CatchmentAreaRoutingModePT.bus, CatchmentAreaRoutingModePT.tram],
+        cutoffs=[25],
+        access_settings=AccessEgressSettings(
+            mode=AccessEgressMode.bicycle, max_time=15, speed=15.0
+        ),
+        egress_settings=AccessEgressSettings(
+            mode=AccessEgressMode.bicycle, max_time=15, speed=15.0
+        ),
+    )
+
+    async with motis_adapter_online.motis_client:
+        response = await motis_adapter_online._get_transit_catchment_area(bike_request)
+
+    assert len(response.polygons) == 1
+    assert response.polygons[0].travel_time == 25
+    assert bike_request.access_settings.mode == AccessEgressMode.bicycle
+    assert bike_request.egress_settings.mode == AccessEgressMode.bicycle
+
+
+async def test_invalid_coordinates_handling(motis_adapter_online):
+    """Test handling of coordinates in remote areas with no transit coverage."""
+    remote_request = TransitCatchmentAreaRequest(
+        starting_points=[Coordinates(lat=0.0, lon=-160.0)],
+        transit_modes=[CatchmentAreaRoutingModePT.bus],
+        cutoffs=[15],
         access_settings=AccessEgressSettings.create_walk_settings(),
         egress_settings=AccessEgressSettings.create_walk_settings(),
     )
 
+    async with motis_adapter_online.motis_client:
+        response = await motis_adapter_online._get_transit_catchment_area(
+            remote_request
+        )
+
+    assert response is not None
+    assert len(response.polygons) <= len(remote_request.cutoffs)
+    assert response.metadata.get("total_locations", 0) == 0
+
+
+@pytest.mark.network
+async def test_motis_one_to_all_integration_minimal(simple_berlin_request):
+    """Minimal integration test that can run independently."""
+    adapter = create_motis_adapter()
+
+    try:
+        async with adapter.motis_client:
+            response = await adapter._get_transit_catchment_area(simple_berlin_request)
+        assert len(response.polygons) == len(simple_berlin_request.cutoffs)
+        assert response.metadata.get("source") == "motis_one_to_all"
+    finally:
+        await adapter.motis_client.close()
+
+
+# ============================================================================
+# PLAUSIBILITY AND VALIDATION TESTS
+# ============================================================================
+
 
 @pytest.mark.network
 @pytest.mark.asyncio
@@ -259,9 +440,11 @@ async def test_motis_one_to_all_raw_response_validation(plausibility_tester):
 
     try:
         request = TransitCatchmentAreaRequest(
-            starting_points=[{"lat": 48.1351, "lon": 11.5820}],
+            starting_points=[Coordinates(lat=48.1351, lon=11.5820)],
             transit_modes=[CatchmentAreaRoutingModePT.bus],
             cutoffs=[10, 20],
+            access_settings=AccessEgressSettings.create_walk_settings(),
+            egress_settings=AccessEgressSettings.create_walk_settings(),
         )
 
         motis_request = translate_to_motis_one_to_all_request(request)
@@ -270,22 +453,15 @@ async def test_motis_one_to_all_raw_response_validation(plausibility_tester):
         except Exception as e:
             pytest.skip(f"MOTIS one-to-all service unavailable: {e}")
 
-        # Validate response structure
         issues = plausibility_tester.validate_raw_motis_response(motis_response)
 
-        # Log any issues for debugging but allow minor issues
         if issues:
             logger.warning(f"Validation issues found: {issues}")
 
-        # Basic assertions
         assert isinstance(motis_response, dict), "Response should be a dictionary"
         assert "all" in motis_response, "Response should contain 'all' field"
         assert isinstance(motis_response["all"], list), "'all' field should be a list"
-
-        # Should have at least some reachable locations in Munich
-        assert (
-            len(motis_response["all"]) > 0
-        ), "Should have at least some reachable locations"
+        assert len(motis_response["all"]) > 0, "Should have reachable locations"
 
     finally:
         await adapter.motis_client.close()
@@ -293,29 +469,35 @@ async def test_motis_one_to_all_raw_response_validation(plausibility_tester):
 
 @pytest.mark.network
 @pytest.mark.asyncio
-async def test_motis_response_parsing(sample_request):
+async def test_motis_response_parsing(plausibility_tester):
     """Test that MOTIS response can be parsed into our internal format."""
     adapter = create_motis_adapter()
 
     try:
-        motis_request = translate_to_motis_one_to_all_request(sample_request)
+        request = TransitCatchmentAreaRequest(
+            starting_points=[Coordinates(lat=48.1351, lon=11.5820)],
+            transit_modes=[
+                CatchmentAreaRoutingModePT.bus,
+                CatchmentAreaRoutingModePT.subway,
+            ],
+            cutoffs=[10, 20, 30],
+            access_settings=AccessEgressSettings.create_walk_settings(),
+            egress_settings=AccessEgressSettings.create_walk_settings(),
+        )
+
+        motis_request = translate_to_motis_one_to_all_request(request)
         try:
             motis_response = await adapter.motis_client.one_to_all(motis_request)
         except Exception as e:
             pytest.skip(f"MOTIS one-to-all service unavailable: {e}")
 
-        # Parse the response
-        parsed_response = parse_motis_one_to_all_response(
-            motis_response, sample_request
-        )
+        parsed_response = parse_motis_one_to_all_response(motis_response, request)
 
-        # Validate parsed response
         assert parsed_response is not None, "Should successfully parse response"
         assert hasattr(parsed_response, "polygons"), "Should have polygons attribute"
         assert len(parsed_response.polygons) > 0, "Should generate at least one polygon"
 
-        # Check polygon structure
-        max_cutoff = max(sample_request.cutoffs)
+        max_cutoff = max(request.cutoffs)
         for polygon in parsed_response.polygons:
             assert hasattr(polygon, "travel_time"), "Polygon should have travel_time"
             assert polygon.travel_time > 0, "Travel time should be positive"
@@ -329,29 +511,35 @@ async def test_motis_response_parsing(sample_request):
 
 @pytest.mark.network
 @pytest.mark.asyncio
-async def test_adapter_consistency(sample_request):
+async def test_adapter_consistency(plausibility_tester):
     """Test that adapter and direct parsing produce consistent results."""
     adapter = create_motis_adapter()
 
     try:
-        # Get response through adapter
+        request = TransitCatchmentAreaRequest(
+            starting_points=[Coordinates(lat=48.1351, lon=11.5820)],
+            transit_modes=[
+                CatchmentAreaRoutingModePT.bus,
+                CatchmentAreaRoutingModePT.subway,
+            ],
+            cutoffs=[10, 20],
+            access_settings=AccessEgressSettings.create_walk_settings(),
+            egress_settings=AccessEgressSettings.create_walk_settings(),
+        )
+
         try:
-            adapter_response = await adapter._get_transit_catchment_area(sample_request)
+            adapter_response = await adapter._get_transit_catchment_area(request)
         except Exception as e:
             pytest.skip(f"MOTIS adapter service unavailable: {e}")
 
-        # Get response directly and parse
-        motis_request = translate_to_motis_one_to_all_request(sample_request)
+        motis_request = translate_to_motis_one_to_all_request(request)
         try:
             motis_response = await adapter.motis_client.one_to_all(motis_request)
         except Exception as e:
             pytest.skip(f"MOTIS one-to-all service unavailable: {e}")
 
-        direct_response = parse_motis_one_to_all_response(
-            motis_response, sample_request
-        )
+        direct_response = parse_motis_one_to_all_response(motis_response, request)
 
-        # Compare results
         assert adapter_response is not None, "Adapter should return a response"
         assert direct_response is not None, "Direct parsing should return a response"
 
@@ -376,17 +564,12 @@ async def test_comprehensive_plausibility(plausibility_tester):
     except Exception as e:
         pytest.skip(f"MOTIS plausibility test service unavailable: {e}")
 
-    # Should not have errored
     assert (
         "error" not in results
     ), f"Test should not error: {results.get('error', 'N/A')}"
-
-    # Should have basic structure
     assert "validation_results" in results
     assert "raw_response_stats" in results
     assert "parsed_response_stats" in results
-
-    # Should have found locations and generated polygons
     assert (
         results["raw_response_stats"]["total_locations"] > 0
     ), "Should find reachable locations"
@@ -394,7 +577,6 @@ async def test_comprehensive_plausibility(plausibility_tester):
         results["parsed_response_stats"]["polygon_count"] > 0
     ), "Should generate polygons"
 
-    # Log results for manual inspection
     logger.info(
         f"Plausibility test results: {json.dumps(results, indent=2, default=str)}"
     )
@@ -402,7 +584,6 @@ async def test_comprehensive_plausibility(plausibility_tester):
 
 def test_location_entry_validation(plausibility_tester):
     """Test validation of individual location entries."""
-    # Valid location entry
     valid_location = {
         "place": {"lat": 48.1351, "lon": 11.5820, "name": "Test Station"},
         "duration": 15,
@@ -411,10 +592,9 @@ def test_location_entry_validation(plausibility_tester):
     issues = plausibility_tester._validate_location_entry(valid_location, 0)
     assert len(issues) == 0, f"Valid location should have no issues: {issues}"
 
-    # Invalid location entry
     invalid_location = {
-        "place": {"lat": "invalid", "lng": 200},  # Invalid lat, lng out of bounds
-        "duration": 150,  # Too long travel time
+        "place": {"lat": "invalid", "lng": 200},
+        "duration": 150,
     }
 
     issues = plausibility_tester._validate_location_entry(invalid_location, 0)
@@ -423,17 +603,14 @@ def test_location_entry_validation(plausibility_tester):
 
 def test_place_data_validation(plausibility_tester):
     """Test validation of place data within location entries."""
-    # Valid place data
     valid_place = {"lat": 48.1351, "lon": 11.5820, "name": "Test Location"}
     issues = plausibility_tester._validate_place_data(valid_place, 0)
     assert len(issues) == 0, f"Valid place should have no issues: {issues}"
 
-    # Test lng vs lon handling
     place_with_lng = {"lat": 48.1351, "lng": 11.5820, "name": "Test Location"}
     issues = plausibility_tester._validate_place_data(place_with_lng, 0)
     assert len(issues) == 0, f"Place with lng field should be valid: {issues}"
 
-    # Invalid place data
-    invalid_place = {"lat": 200, "lon": -200}  # Out of bounds coordinates
+    invalid_place = {"lat": 200, "lon": -200}
     issues = plausibility_tester._validate_place_data(invalid_place, 0)
     assert len(issues) > 0, "Invalid place should have issues"
diff --git a/packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_online.py b/packages/python/goatlib/tests/integration/routing/adapter/test_motis_adapter_online.py
similarity index 100%
rename from packages/python/goatlib/tests/integration/routing/ab/test_motis_adapter_online.py
rename to packages/python/goatlib/tests/integration/routing/adapter/test_motis_adapter_online.py
diff --git a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_adapter_one_to_all.py b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_adapter_one_to_all.py
deleted file mode 100644
index 05c20b85d..000000000
--- a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_adapter_one_to_all.py
+++ /dev/null
@@ -1,210 +0,0 @@
-import logging
-
-import pytest
-from goatlib.routing.adapters.motis.motis_adapter import create_motis_adapter
-from goatlib.routing.schemas.base import (
-    AccessEgressMode,
-    CatchmentAreaRoutingModePT,
-    Coordinates,
-)
-from goatlib.routing.schemas.catchment_area_transit import (
-    AccessEgressSettings,
-    TransitCatchmentAreaRequest,
-)
-
-logger = logging.getLogger(__name__)
-
-
-async def test_basic_one_to_all_success():
-    """Test basic one-to-all functionality returns valid catchment areas."""
-    adapter = create_motis_adapter()
-
-    berlin_request = TransitCatchmentAreaRequest(
-        starting_points=[Coordinates(lat=52.520008, lon=13.404954)],  # Berlin center
-        cutoffs=[15, 30],
-        transit_modes=[CatchmentAreaRoutingModePT.bus, CatchmentAreaRoutingModePT.tram],
-        access_settings=AccessEgressSettings(
-            mode=AccessEgressMode.walk, max_time=10, speed=5.0
-        ),
-        egress_settings=AccessEgressSettings(
-            mode=AccessEgressMode.walk, max_time=10, speed=5.0
-        ),
-    )
-
-    async with adapter.motis_client:
-        response = await adapter._get_transit_catchment_area(berlin_request)
-
-    # Basic structure checks
-    assert response is not None
-    assert len(response.polygons) == len(berlin_request.cutoffs)
-    assert response.metadata.get("total_locations", 0) > 0
-    assert response.metadata.get("source") == "motis_one_to_all"
-
-    # Check each polygon
-    for polygon in response.polygons:
-        assert polygon.travel_time in berlin_request.cutoffs
-        assert hasattr(polygon, "points")
-        assert isinstance(polygon.points, list)
-
-        # Geometry may be None initially, can be generated from points
-        if polygon.geometry is not None:
-            assert polygon.geometry["type"] == "Polygon"
-            assert "coordinates" in polygon.geometry
-        else:
-            # Test that geometry can be generated from points
-            polygon.set_geometry_from_points()
-            if polygon.points:  # Only check if there are points
-                assert polygon.geometry["type"] == "Polygon"
-                assert "coordinates" in polygon.geometry
-
-
-async def test_multiple_cutoffs():
-    """Test that multiple travel time cutoffs generate correct polygons."""
-    adapter = create_motis_adapter()
-
-    munich_request = TransitCatchmentAreaRequest(
-        starting_points=[Coordinates(lat=48.137154, lon=11.576124)],  # Munich center
-        cutoffs=[10, 20, 30],
-        transit_modes=[CatchmentAreaRoutingModePT.bus, CatchmentAreaRoutingModePT.tram],
-        access_settings=AccessEgressSettings(
-            mode=AccessEgressMode.walk, max_time=10, speed=5.0
-        ),
-        egress_settings=AccessEgressSettings(
-            mode=AccessEgressMode.walk, max_time=10, speed=5.0
-        ),
-    )
-
-    async with adapter.motis_client:
-        response = await adapter._get_transit_catchment_area(munich_request)
-
-    assert len(response.polygons) == len(munich_request.cutoffs)
-
-    # Polygons should be ordered by travel time
-    travel_times = [p.travel_time for p in response.polygons]
-    assert sorted(travel_times) == sorted(munich_request.cutoffs)
-
-
-async def test_different_transit_modes(motis_adapter_online):
-    """Test different combinations of transit modes."""
-    rail_only_request = TransitCatchmentAreaRequest(
-        starting_points=[{"lat": 52.5200, "lon": 13.4050}],
-        transit_modes=[CatchmentAreaRoutingModePT.rail],
-        cutoffs=[20],
-        access_settings=AccessEgressSettings.create_walk_settings(),
-        egress_settings=AccessEgressSettings.create_walk_settings(),
-    )
-
-    response = await motis_adapter_online._get_transit_catchment_area(rail_only_request)
-
-    assert len(response.polygons) == 1
-
-
-async def test_single_cutoff(motis_adapter_online):
-    """Test with a single travel time cutoff."""
-    single_cutoff_request = TransitCatchmentAreaRequest(
-        starting_points=[
-            {"lat": 48.1351, "lon": 11.5820}  # Munich
-        ],
-        transit_modes=[
-            CatchmentAreaRoutingModePT.subway,
-            CatchmentAreaRoutingModePT.tram,
-        ],
-        cutoffs=[20],
-        access_settings=AccessEgressSettings.create_walk_settings(),
-        egress_settings=AccessEgressSettings.create_walk_settings(),
-    )
-
-    response = await motis_adapter_online._get_transit_catchment_area(
-        single_cutoff_request
-    )
-
-    assert len(response.polygons) == 1
-    assert response.polygons[0].travel_time == 20
-
-
-async def test_geometry_structure(motis_adapter_online, berlin_request):
-    """Test that returned geometry has correct GeoJSON structure."""
-    response = await motis_adapter_online._get_transit_catchment_area(berlin_request)
-
-    for polygon in response.polygons:
-        # Check that polygon has points field
-        assert hasattr(polygon, "points")
-        assert isinstance(polygon.points, list)
-
-        # If geometry is None, generate it from points for testing
-        if polygon.geometry is None:
-            polygon.set_geometry_from_points()
-
-        # Now test the geometry structure (if points exist)
-        if polygon.points and polygon.geometry:
-            assert polygon.geometry["type"] == "Polygon"
-            assert "coordinates" in polygon.geometry
-            if polygon.geometry["coordinates"]:
-                coord_ring = polygon.geometry["coordinates"][0]
-                assert len(coord_ring) >= 4
-                assert len(coord_ring[0]) == 2
-                assert coord_ring[0] == coord_ring[-1]
-
-
-async def test_bike_access_egress(motis_adapter_online):
-    """Test catchment area with bicycle access and egress modes."""
-    bike_request = TransitCatchmentAreaRequest(
-        starting_points=[{"lat": 52.5200, "lon": 13.4050}],
-        transit_modes=[
-            CatchmentAreaRoutingModePT.bus,
-            CatchmentAreaRoutingModePT.tram,
-        ],
-        cutoffs=[25],
-        access_settings=AccessEgressSettings(
-            mode=AccessEgressMode.bicycle, max_time=15, speed=15.0
-        ),
-        egress_settings=AccessEgressSettings(
-            mode=AccessEgressMode.bicycle, max_time=15, speed=15.0
-        ),
-    )
-
-    response = await motis_adapter_online._get_transit_catchment_area(bike_request)
-
-    assert len(response.polygons) == 1
-    assert response.polygons[0].travel_time == 25
-    assert bike_request.access_settings.mode == AccessEgressMode.bicycle
-    assert bike_request.egress_settings.mode == AccessEgressMode.bicycle
-
-
-async def test_invalid_coordinates_handling(motis_adapter_online):
-    """Test handling of coordinates in remote areas with no transit coverage."""
-    # Use coordinates in the middle of the Pacific Ocean where MOTIS has no data
-    remote_request = TransitCatchmentAreaRequest(
-        starting_points=[
-            {"lat": 0.0, "lon": -160.0}  # Middle of Pacific Ocean
-        ],
-        transit_modes=[CatchmentAreaRoutingModePT.bus],
-        cutoffs=[15],
-        access_settings=AccessEgressSettings.create_walk_settings(),
-        egress_settings=AccessEgressSettings.create_walk_settings(),
-    )
-
-    response = await motis_adapter_online._get_transit_catchment_area(remote_request)
-
-    # Should return valid structure but likely with no or minimal locations
-    assert response is not None
-    assert len(response.polygons) <= len(remote_request.cutoffs)
-    assert response.metadata.get("total_locations", 0) == 0
-
-
-@pytest.mark.network
-async def test_motis_one_to_all_integration_minimal(
-    simple_berlin_request: TransitCatchmentAreaRequest,
-) -> None:
-    """Minimal integration test that can run independently."""
-    from goatlib.routing.adapters.motis import create_motis_adapter
-
-    adapter = create_motis_adapter()
-
-    try:
-        response = await adapter._get_transit_catchment_area(simple_berlin_request)
-        assert len(response.polygons) == len(simple_berlin_request.cutoffs)
-        assert response.metadata.get("source") == "motis_one_to_all"
-
-    finally:
-        await adapter.motis_client.close()
diff --git a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_buffered_station.py b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_buffered_station.py
index 8689a98a3..0ba838200 100644
--- a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_buffered_station.py
+++ b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_buffered_station.py
@@ -20,6 +20,29 @@
 logger = logging.getLogger(__name__)
 
 
+# ============================================================================
+# FIXTURES
+# ============================================================================
+
+
+@pytest.fixture
+def pt_buffer_config() -> Dict[str, Any]:
+    """Single configuration for Public Transport Station Access."""
+    return {
+        "name": "pt_station_walk",
+        "title": "🚌 Public Transport Access",
+        "distances": [200, 400, 600],  # Walking distance from stations
+        "description": "Buffer zones around reachable stations",
+        "use_case": "Transit Coverage Analysis",
+    }
+
+
+@pytest.fixture
+def buffered_stations_dir(tmp_path):
+    """Temporary directory for buffered station outputs."""
+    return tmp_path / "buffered_stations"
+
+
 def create_pt_buffer_params(
     reachable_locations: List[Dict[str, Any]],
     config: Dict[str, Any],
@@ -63,22 +86,9 @@ def create_pt_buffer_params(
     )
 
 
-@pytest.fixture
-def pt_buffer_config() -> Dict[str, Any]:
-    """Single configuration for Public Transport Station Access."""
-    return {
-        "name": "pt_station_walk",
-        "title": "🚌 Public Transport Access",
-        "distances": [200, 400, 600],  # Walking distance from stations
-        "description": "Buffer zones around reachable stations",
-        "use_case": "Transit Coverage Analysis",
-    }
-
-
-@pytest.fixture
-def buffered_stations_dir(tmp_path):
-    """Temporary directory for buffered station outputs."""
-    return tmp_path / "buffered_stations"
+# ============================================================================
+# # TESTS
+# ============================================================================
 
 
 @pytest.mark.asyncio
diff --git a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_get_isochrone.py b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_get_isochrone.py
index 07770c0be..6ee7edbe7 100644
--- a/packages/python/goatlib/tests/integration/routing/catchment/test_motis_get_isochrone.py
+++ b/packages/python/goatlib/tests/integration/routing/catchment/test_motis_get_isochrone.py
@@ -1,9 +1,11 @@
-# tests/adapters/test_motis_adapter_e2e.py
-
-import json
 import logging
+import time
+from pathlib import Path
 
+import fast_routing_py as routing_rs
 import pytest
+from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
+from goatlib.routing.adapters.motis import create_motis_adapter
 from goatlib.routing.adapters.motis.motis_adapter import (
     MotisPlanApiAdapter,
 )
@@ -12,35 +14,20 @@
     CatchmentAreaType,
     Coordinates,
 )
-from goatlib.routing.schemas.catchment import CatchmentRequest, CatchmentResponse
+from goatlib.routing.schemas.catchment import CatchmentRequest
 from goatlib.routing.schemas.catchment_area_transit import (
     AccessEgressSettings,
+    TransitCatchmentAreaRequest,
 )
 
-# Setup logger
 logger = logging.getLogger(__name__)
 
-# Assume your test data file is located here relative to your project root
-TEST_NETWORK_PATH = "packages/python/goatlib/tests/data/network/network.parquet"
-
-# --- End-to-End Test ---
-
 
-@pytest.mark.network  # Mark this test as requiring the network
 @pytest.mark.asyncio
-async def test_get_isochrone_live_e2e_chained_workflow(
-    motis_adapter_online: MotisPlanApiAdapter, mocker
+@pytest.mark.network
+async def test_get_isochrone(
+    motis_adapter_online: MotisPlanApiAdapter,
 ):
-    """
-    Tests the full chained workflow against a live MOTIS API and the real Rust engine.
-    This test will fail if the MOTIS API is unavailable or if the local network
-    data doesn't cover the requested area (Munich).
-    """
-    # Arrange
-    # We still spy on os.unlink to ensure cleanup happens correctly.
-    mock_unlink = mocker.patch("os.unlink")
-
-    # A realistic request for Munich, which should yield results
     request = CatchmentRequest(
         starting_points=[Coordinates(lat=48.1351, lon=11.5820)],  # Munich center
         cutoffs=[15, 30],  # 15 and 30-minute isochrones
@@ -53,101 +40,293 @@ async def test_get_isochrone_live_e2e_chained_workflow(
         egress_settings=AccessEgressSettings.create_walk_settings(max_time=15),
         type=CatchmentAreaType.polygon,
     )
+    response = await motis_adapter_online.get_isochrone(request)
+
+    assert response.results
+    r = response.results[0]
+
+    assert r.pt_stations_found > 0
+    assert r.successful_routing > 0
+    assert r.total_reachable_nodes > 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.network
+async def test_complete_motis_rust_workflow(network_file: Path):
+    """Complete MOTIS + Rust workflow using the correct adapter interface."""
+
+    # Test data path
+
+    if not network_file.exists():
+        logger.info(f"❌ Test file not found: {network_file}")
+        pytest.skip(f"Test file not found: {network_file}")
+
+    # Step 1: Use MOTIS adapter directly with the interface
+    center = Coordinates(lat=48.1351, lon=11.5820)  # Munich center
+    motis_request = TransitCatchmentAreaRequest(
+        starting_points=[center],  # Munich
+        transit_modes=[
+            CatchmentAreaRoutingModePT.rail,
+            CatchmentAreaRoutingModePT.subway,
+            CatchmentAreaRoutingModePT.tram,
+        ],
+        cutoffs=[5],  # 5 minutes
+        access_settings=AccessEgressSettings.create_walk_settings(),
+        egress_settings=AccessEgressSettings.create_walk_settings(),
+    )
 
-    # Act
-    logger.info("Sending live E2E request to MOTIS and local Rust engine...")
+    # Use the MOTIS client directly to get raw station data
+    adapter = create_motis_adapter()
     try:
-        response = await motis_adapter_online.get_isochrone(request)
-        # Close the client session after the test is done
-        await motis_adapter_online.motis_client.close()
+        # Get raw MOTIS data using the converter functions
+        from goatlib.routing.adapters.motis.motis_converters import (
+            extract_bus_stations_for_buffering,
+            translate_to_motis_one_to_all_request,
+        )
+
+        # Convert our request to MOTIS format and call directly
+        motis_req = translate_to_motis_one_to_all_request(motis_request)
+        logger.info(f"MOTIS request: {motis_req}")
+
+        raw_motis_response = await adapter.motis_client.one_to_all(motis_req)
+        logger.info("MOTIS raw response received")
+
+        # Extract stations from the raw response
+        raw_stations = extract_bus_stations_for_buffering(raw_motis_response)
+        logger.info(f"Extracted {len(raw_stations)} transit stations")
+
+        if not raw_stations:
+            logger.info("❌ No stations found in MOTIS response")
+            pytest.skip("No station data from MOTIS")
+
+        # Show first few stations for debugging
+        for i, station in enumerate(raw_stations):
+            coords = station["coordinates"]  # [lon, lat]
+            logger.info(
+                f"   Station {i+1}: {station.get('name', 'Unknown')} at [{coords[1]:.4f}, {coords[0]:.4f}]"
+            )
+
+        # Convert to our format
+        stations_data = []
+        for station in raw_stations:
+            coords = station["coordinates"]  # [lon, lat]
+            stations_data.append(
+                {
+                    "name": station.get("name", "Unknown"),
+                    "lat": coords[1],  # latitude
+                    "lon": coords[0],  # longitude
+                    "transit_time": station.get("duration_minutes", 0),
+                }
+            )
+        # final_response = CatchmentResponse(last_mile_catchment=stations_data)
+
     except Exception as e:
-        await motis_adapter_online.motis_client.close()
-        pytest.fail(f"The live get_isochrone call failed with an exception: {e}")
+        await adapter.motis_client.close()
+        logger.error(f"MOTIS API error: {e}")
+        pytest.skip(f"MOTIS API unavailable: {e}")
 
-    logger.info(f"Received live response: {response.dict()}")
+    # Step 2: Process with Rust routing using the fast functions
+    successful_routing = 0
+    total_reachable = 0
 
-    # Assert
-    # 1. Assertions on the response structure
-    assert isinstance(response, CatchmentResponse)
-    assert len(response.results) == 2, "Should have one result per cutoff"
-    assert (
-        mock_unlink.call_count > 0
-    ), "Temporary graph files should have been created and cleaned up"
-
-    # 2. Assertions on the 15-minute cutoff result
-    # These are "behavioral" assertions, not hardcoded numbers.
-    result_15_min = response.results[0]
-    assert result_15_min.cutoff_minutes == 15
-    assert result_15_min.pt_stations_found is not None
-    assert (
-        result_15_min.pt_stations_found > 0
-    ), "MOTIS should have found at least one station within 15 mins"
-    assert (
-        result_15_min.last_mile_walkshed_nodes > 0
-    ), "Rust engine should have found reachable nodes from the stations"
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        # Load network around Munich - larger area to ensure we catch stations
+        subset_table = proc.load_network(
+            center=center, buffer_radius=15000.0
+        )  # 15km radius
+        logger.info(f"Loaded network subset: {subset_table}")
 
-    # 3. Assertions on the 30-minute cutoff result
-    result_30_min = response.results[1]
-    assert result_30_min.cutoff_minutes == 30
-    assert result_30_min.pt_stations_found is not None
-    assert (
-        result_30_min.pt_stations_found >= result_15_min.pt_stations_found
-    ), "30-min cutoff should find at least as many stations as 15-min"
+        # Process all stations in batch using calculate_multiple_isochrones
+        station_coordinates = [
+            Coordinates(lat=station["lat"], lon=station["lon"])
+            for station in stations_data
+        ]
+
+        try:
+            # Create artificial nodes for all stations at once
+            result = proc.create_artificial_nodes_for_points(
+                station_coordinates, subset_table, search_radius_m=500.0
+            )
+
+            if isinstance(result, tuple):
+                output_path, artificial_node_ids = result
+                logger.info(
+                    f"Created: {len(artificial_node_ids)} artificial nodes for {len(station_coordinates)} stations"
+                )
+
+                # Use batch routing with calculate_multiple_isochrones
+
+                import fast_routing_py as routing
+
+                network = routing.load_network(output_path)
+                max_cost = 300  # 5 minutes in seconds
+
+                # Use calculate_multiple_isochrones for all stations at once
+                routing_results = network.calculate_multiple_isochrones(
+                    start_nodes=artificial_node_ids, max_cost=max_cost
+                )
+
+                # Process results
+                for i, routing_result in enumerate(routing_results):
+                    if i < len(stations_data):
+                        station = stations_data[i]
+                        reachable = routing_result.reachable_nodes
+                        successful_routing += 1
+                        total_reachable += reachable
+            else:
+                logger.warning("⚠️ Network processing failed")
+
+        except Exception as e:
+            logger.warning(f"❌ Station processing failed: {e}")
+
+    # Step 3: Results
+    success_rate = (
+        (successful_routing / len(stations_data) * 100) if stations_data else 0
+    )
+    logger.info(f"   MOTIS stations found: {len(stations_data)}")
+    logger.info(f"   Successful routing: {successful_routing}")
+    logger.info(f"   Success rate: {success_rate:.1f}%")
+    logger.info(f"   Total reachable nodes: {total_reachable:,}")
+
+    # Assertions
+    assert len(stations_data) > 0, "Should find transit stations from MOTIS"
     assert (
-        result_30_min.last_mile_walkshed_nodes >= result_15_min.last_mile_walkshed_nodes
-    ), "30-min cutoff should cover a larger or equal area"
-    # We can be more confident that the 30-min result is strictly larger
-    assert result_30_min.pt_stations_found > 0
-    assert result_30_min.last_mile_walkshed_nodes > 0
+        successful_routing > 0
+    ), "Should successfully route from at least some stations"
+    assert total_reachable > 0, "Should find reachable nodes"
 
 
-import json
+def test_catchment_workflow(network_file: Path):
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        # Use the new optimized method that combines all preprocessing
+        start_coords = Coordinates(lat=48.1351, lon=11.5820)
 
+        # Define cutoffs first to ensure network preparation covers the max cutoff
+        cutoffs_minutes = [10, 20, 30]
+        max_cutoff = max(cutoffs_minutes)
 
-def get_all_attributes(obj):
-    """Get all attributes of an object."""
-    attrs = {}
+        parquet_path, start_node_id = proc.prepare_routing_network(
+            start_point=start_coords,
+            buffer_radius=1000.0,
+            travel_time_minutes=max_cutoff,  # Use max cutoff for network preparation
+            speed_kmh=5.0,
+        )
 
-    # Get __dict__ attributes
-    if hasattr(obj, "__dict__"):
-        for k, v in obj.__dict__.items():
-            attrs[k] = v
+        # Load network with fast_routing_py and calculate isochrone
+        network = routing_rs.load_network(parquet_path)
 
-    # Get properties via getattr
-    for attr_name in dir(obj):
-        if not attr_name.startswith("_"):
-            try:
-                attr_value = getattr(obj, attr_name)
-                if not callable(attr_value) and attr_name not in attrs:
-                    attrs[attr_name] = attr_value
-            except:
-                attrs[attr_name] = "<Error accessing>"
+        # Calculate isochrones for the requested cutoffs (convert minutes to seconds)
+        cutoffs_seconds = [c * 60 for c in cutoffs_minutes]
+        results = network.calculate_isochrone_multiple_times(
+            start_node=start_node_id, time_thresholds=cutoffs_seconds
+        )
 
-    return attrs
+        assert len(results) == 3  # One result per cutoff
+        for i, result in enumerate(results):
+            assert result.reachable_nodes > 0
+            logger.info(
+                f"Cutoff {cutoffs_minutes[i]} min: {result.reachable_nodes} reachable nodes"
+            )
 
 
-@pytest.mark.asyncio
-@pytest.mark.network
-async def test_complete_motis_rust_workflow(
-    motis_adapter_online: MotisPlanApiAdapter,
-):
-    request = CatchmentRequest(
-        starting_points=[Coordinates(lat=48.1351, lon=11.5820)],  # Munich center
-        cutoffs=[15, 30],  # 15 and 30-minute isochrones
-        transit_modes=[
-            CatchmentAreaRoutingModePT.rail,
-            CatchmentAreaRoutingModePT.subway,
-            CatchmentAreaRoutingModePT.tram,
-        ],
-        access_settings=AccessEgressSettings.create_walk_settings(max_time=10),
-        egress_settings=AccessEgressSettings.create_walk_settings(max_time=15),
-        type=CatchmentAreaType.polygon,
+def test_split_edge_accuracy_benchmark(network_file: Path):
+    """
+    Test the accuracy improvements of the optimized routing network preparation.
+    """
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        start_coords = Coordinates(lat=48.1351, lon=11.5820)
+
+        # Test optimized routing network preparation
+        t1 = time.time()
+        parquet_path, start_node_id = proc.prepare_routing_network(
+            start_point=start_coords, buffer_radius=500.0
+        )
+        t2 = time.time()
+
+        prep_time = (t2 - t1) * 1000
+
+        logger.info(f"Optimized routing prep: {prep_time:.1f}ms")
+        logger.info(f"  Start node ID: {start_node_id}")
+        logger.info(f"  Output file: {parquet_path}")
+
+        # Load the result to verify network quality
+        import duckdb
+
+        con = duckdb.connect(":memory:")
+        con.execute("INSTALL spatial; LOAD spatial;")
+
+        # Get network statistics
+        network_info = con.execute(f"""
+            SELECT
+                COUNT(*) as edge_count,
+                COUNT(DISTINCT source) as unique_sources,
+                COUNT(DISTINCT target) as unique_targets,
+                AVG(length_m) as avg_length
+            FROM read_parquet('{parquet_path}')
+        """).fetchone()
+
+        edge_count = network_info[0]
+        avg_length = network_info[3]
+
+        logger.info(f"  Network edges: {edge_count}")
+        logger.info(f"  Avg edge length: {avg_length:.1f}m")
+
+        # Verify the start node exists in the network
+        start_node_exists = con.execute(f"""
+            SELECT COUNT(*) FROM read_parquet('{parquet_path}')
+            WHERE source = {start_node_id} OR target = {start_node_id}
+        """).fetchone()[0]
+
+        logger.info(f"  Start node connectivity: {start_node_exists} edges")
+
+        # Assertions for quality
+        assert edge_count > 100, "Network should have substantial edges"
+        assert start_node_exists > 0, "Start node should be connected to the network"
+        assert avg_length > 0, "Edges should have positive length"
+        assert (
+            prep_time < 150
+        ), f"Preparation took {prep_time:.1f}ms, should be under 150ms"
+
+        logger.info("✓ Optimized routing network accuracy benchmark PASSED")
+
+
+# add a test to try calculate_multiple_isochrones on the rust_network_analysis module
+def test_rust_network_multiple_isochrones(network_file: Path):
+    """
+    Test the Rust network analysis library's ability to calculate multiple isochrones.
+    """
+
+    # Use InMemoryNetworkProcessor to prepare a properly formatted network for Rust
+    with InMemoryNetworkProcessor(input_path=str(network_file)) as proc:
+        start_coords = Coordinates(lat=48.1351, lon=11.5820)
+
+        # Prepare the network in the format expected by the Rust library
+        parquet_path, start_node_id = proc.prepare_routing_network(
+            start_point=start_coords,
+            buffer_radius=1000.0,
+            travel_time_minutes=20.0,
+            speed_kmh=5.0,
+        )
+
+        # Load the network using the Rust library
+        network = routing_rs.load_network(parquet_path)
+
+    # Define multiple cutoffs in seconds
+    cutoffs_seconds = [300, 600, 900]  # 5min, 10min, 15min
+
+    # Calculate multiple isochrones
+    results = network.calculate_isochrone_multiple_times(
+        start_node=start_node_id, time_thresholds=cutoffs_seconds
     )
-    response = await motis_adapter_online.get_isochrone(request)
 
-    assert response.results
-    r = response.results[0]
+    assert len(results) == len(cutoffs_seconds), "Should return results for all cutoffs"
 
-    assert r.pt_stations_found > 0
-    assert r.successful_routing > 0
-    assert r.total_reachable_nodes > 0
+    for i, result in enumerate(results):
+        assert (
+            result.reachable_nodes > 0
+        ), f"Isochrone for cutoff {cutoffs_seconds[i]}s should have reachable nodes"
+        logger.info(
+            f"Cutoff {cutoffs_seconds[i]//60} min: {result.reachable_nodes} reachable nodes"
+        )
+
+    logger.info("✓ Rust network multiple isochrones test PASSED")
diff --git a/packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py b/packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py
deleted file mode 100644
index ffaf82478..000000000
--- a/packages/python/goatlib/tests/integration/routing/catchment/test_routing_workflow.py
+++ /dev/null
@@ -1,191 +0,0 @@
-import logging
-import os
-from pathlib import Path
-
-import pytest
-from goatlib.analysis.network.network_processor import InMemoryNetworkProcessor
-from goatlib.routing.adapters.motis import create_motis_adapter
-from goatlib.routing.schemas.base import (
-    CatchmentAreaRoutingModePT,
-    Coordinates,
-)
-from goatlib.routing.schemas.catchment import (
-    CatchmentAreaType,
-    CatchmentRequest,
-)
-from goatlib.routing.schemas.catchment_area_transit import (
-    AccessEgressSettings,
-    TransitCatchmentAreaRequest,
-)
-
-logger = logging.getLogger(__name__)
-
-
-# fixture of a standard catchment request in Munich
-@pytest.fixture
-def munich_catchment_request() -> CatchmentRequest:
-    """Create a standard Munich catchment area request."""
-    return CatchmentRequest(
-        starting_points=[
-            Coordinates(lat=48.1351, lon=11.5820)  # Munich center
-        ],
-        cutoffs=[15, 30, 45],  # 15, 30, and 45 minute isochrones
-        type=CatchmentAreaType.point,
-    )
-
-
-@pytest.mark.asyncio
-@pytest.mark.network
-async def test_complete_motis_rust_workflow(munich_catchment_request: CatchmentRequest):
-    """Complete MOTIS + Rust workflow using the correct adapter interface."""
-
-    # Test data path
-    test_file = Path("/app/packages/python/goatlib/tests/data/network/network.parquet")
-    if not test_file.exists():
-        logger.info(f"❌ Test file not found: {test_file}")
-        pytest.skip(f"Test file not found: {test_file}")
-
-    # Step 1: Use MOTIS adapter directly with the interface
-    center = Coordinates(lat=48.1351, lon=11.5820)  # Munich center
-    motis_request = TransitCatchmentAreaRequest(
-        starting_points=[center],  # Munich
-        transit_modes=[
-            CatchmentAreaRoutingModePT.rail,
-            CatchmentAreaRoutingModePT.subway,
-            CatchmentAreaRoutingModePT.tram,
-        ],
-        cutoffs=[15],  # 15 minutes
-        access_settings=AccessEgressSettings.create_walk_settings(),
-        egress_settings=AccessEgressSettings.create_walk_settings(),
-    )
-
-    # Use the MOTIS client directly to get raw station data
-    adapter = create_motis_adapter()
-    try:
-        # Get raw MOTIS data using the converter functions
-        from goatlib.routing.adapters.motis.motis_converters import (
-            extract_bus_stations_for_buffering,
-            translate_to_motis_one_to_all_request,
-        )
-
-        # Convert our request to MOTIS format and call directly
-        motis_req = translate_to_motis_one_to_all_request(motis_request)
-        logger.info(f"MOTIS request: {motis_req}")
-
-        raw_motis_response = await adapter.motis_client.one_to_all(motis_req)
-        logger.info("MOTIS raw response received")
-
-        # Extract stations from the raw response
-        raw_stations = extract_bus_stations_for_buffering(raw_motis_response)
-        logger.info(f"Extracted {len(raw_stations)} transit stations")
-
-        if not raw_stations:
-            logger.info("❌ No stations found in MOTIS response")
-            pytest.skip("No station data from MOTIS")
-
-        # Show first few stations for debugging
-        for i, station in enumerate(raw_stations):
-            coords = station["coordinates"]  # [lon, lat]
-            logger.info(
-                f"   Station {i+1}: {station.get('name', 'Unknown')} at [{coords[1]:.4f}, {coords[0]:.4f}]"
-            )
-
-        # Convert to our format
-        stations_data = []
-        for station in raw_stations:
-            coords = station["coordinates"]  # [lon, lat]
-            stations_data.append(
-                {
-                    "name": station.get("name", "Unknown"),
-                    "lat": coords[1],  # latitude
-                    "lon": coords[0],  # longitude
-                    "transit_time": station.get("duration_minutes", 0),
-                }
-            )
-        # final_response = CatchmentResponse(last_mile_catchment=stations_data)
-
-    except Exception as e:
-        await adapter.motis_client.close()
-        logger.error(f"MOTIS API error: {e}")
-        pytest.skip(f"MOTIS API unavailable: {e}")
-
-    await adapter.motis_client.close()
-
-    # Step 2: Process with Rust routing using the fast functions
-    successful_routing = 0
-    total_reachable = 0
-
-    with InMemoryNetworkProcessor(input_path=str(test_file)) as proc:
-        # Load network around Munich - larger area to ensure we catch stations
-        subset_table = proc.load_network(
-            center=center, buffer_radius=15000.0
-        )  # 15km radius
-        logger.info(f"Loaded network subset: {subset_table}")
-
-        # Process all stations in batch using calculate_multiple_isochrones
-        station_coordinates = [
-            Coordinates(lat=station["lat"], lon=station["lon"])
-            for station in stations_data
-        ]
-
-        try:
-            # Create artificial nodes for all stations at once
-            result = proc.create_artificial_nodes_for_points(
-                station_coordinates, subset_table, search_radius_m=500.0
-            )
-
-            if isinstance(result, tuple):
-                output_path, artificial_node_ids = result
-                logger.info(
-                    f"Created: {len(artificial_node_ids)} artificial nodes for {len(station_coordinates)} stations"
-                )
-
-                # Use batch routing with calculate_multiple_isochrones
-                try:
-                    import fast_routing_py as routing
-
-                    network = routing.load_network(output_path)
-                    max_cost = 300  # 5 minutes in seconds
-
-                    # Use calculate_multiple_isochrones for all stations at once
-                    routing_results = network.calculate_multiple_isochrones(
-                        start_nodes=artificial_node_ids, max_cost=max_cost
-                    )
-
-                    # Process results
-                    for i, routing_result in enumerate(routing_results):
-                        if i < len(stations_data):
-                            station = stations_data[i]
-                            reachable = routing_result.reachable_nodes
-                            successful_routing += 1
-                            total_reachable += reachable
-
-                    # Cleanup
-                    if os.path.exists(output_path):
-                        os.unlink(output_path)
-
-                except Exception as e:
-                    logger.warning(f"❌ Batch routing failed: {e}")
-                    if os.path.exists(output_path):
-                        os.unlink(output_path)
-            else:
-                logger.warning("⚠️ Network processing failed")
-
-        except Exception as e:
-            logger.warning(f"❌ Station processing failed: {e}")
-
-    # Step 3: Results
-    success_rate = (
-        (successful_routing / len(stations_data) * 100) if stations_data else 0
-    )
-    logger.info(f"   MOTIS stations found: {len(stations_data)}")
-    logger.info(f"   Successful routing: {successful_routing}")
-    logger.info(f"   Success rate: {success_rate:.1f}%")
-    logger.info(f"   Total reachable nodes: {total_reachable:,}")
-
-    # Assertions
-    assert len(stations_data) > 0, "Should find transit stations from MOTIS"
-    assert (
-        successful_routing > 0
-    ), "Should successfully route from at least some stations"
-    assert total_reachable > 0, "Should find reachable nodes"
diff --git a/packages/python/goatlib/tests/integration/network/test_rust_network_analysis.py b/packages/python/goatlib/tests/integration/routing/catchment/test_rust_network_analysis.py
similarity index 100%
rename from packages/python/goatlib/tests/integration/network/test_rust_network_analysis.py
rename to packages/python/goatlib/tests/integration/routing/catchment/test_rust_network_analysis.py
diff --git a/packages/python/goatlib/tests/unit/routing/test_ab_routing_schemas.py b/packages/python/goatlib/tests/unit/routing/test_ab_schemas.py
similarity index 79%
rename from packages/python/goatlib/tests/unit/routing/test_ab_routing_schemas.py
rename to packages/python/goatlib/tests/unit/routing/test_ab_schemas.py
index 8360a1f85..2fa28e073 100644
--- a/packages/python/goatlib/tests/unit/routing/test_ab_routing_schemas.py
+++ b/packages/python/goatlib/tests/unit/routing/test_ab_schemas.py
@@ -8,7 +8,7 @@
     ABRoutingRequest,
     ABRoutingResponse,
 )
-from goatlib.routing.schemas.base import Coordinates, Mode
+from goatlib.routing.schemas.base import Coordinates, Mode, Route
 from pydantic import ValidationError
 
 # =====================================================================
@@ -164,3 +164,50 @@ def test_ab_response_creation_success(valid_route_data: Dict[str, Any]) -> None:
     )
 
     assert response.type == "FeatureCollection"
+
+
+@pytest.mark.parametrize(
+    "lat, lon, expected_error",
+    [
+        (91.0, 13.4050, ValueError),
+        (-91.0, 13.4050, ValueError),
+        (52.5200, 181.0, ValueError),
+        (52.5200, -181.0, ValueError),
+    ],
+    ids=["lat-too-high", "lat-too-low", "lon-too-high", "lon-too-low"],
+)
+def test_coordinates_invalid_coordinates(
+    lat: float, lon: float, expected_error: type
+) -> None:
+    """Test that invalid coordinates raise a ValueError."""
+    with pytest.raises(expected_error):
+        Coordinates(lat=lat, lon=lon)
+
+
+def test_coordinates_valid() -> None:
+    """Test creating a valid Coordinates."""
+    coords = Coordinates(lat=52.5200, lon=13.4050)
+    assert coords.lat == 52.5200
+    assert coords.lon == 13.4050
+
+
+def test_transport_mode_enum() -> None:
+    """Test that Mode enum has expected values."""
+    assert Mode.walk == "walk"
+    assert Mode.bus == "bus"
+    assert Mode.car == "car"
+    assert Mode.transit == "transit"
+
+
+# add a test for route schema
+def test_route_schema() -> None:
+    """Test creating a Route object."""
+    route = Route(
+        duration=3600,
+        distance=10000,
+        departure_time=datetime.now(timezone.utc),
+    )
+    assert route.duration == 3600
+    assert route.distance == 10000
+    assert route.departure_time is not None
+    assert route.route_id is not None
diff --git a/packages/python/goatlib/tests/unit/routing/test_route_validation.py b/packages/python/goatlib/tests/unit/routing/test_ab_validation.py
similarity index 95%
rename from packages/python/goatlib/tests/unit/routing/test_route_validation.py
rename to packages/python/goatlib/tests/unit/routing/test_ab_validation.py
index 79bfa98d5..4cf1cca1f 100644
--- a/packages/python/goatlib/tests/unit/routing/test_route_validation.py
+++ b/packages/python/goatlib/tests/unit/routing/test_ab_validation.py
@@ -9,6 +9,7 @@
 )
 
 
+# Helper functions to create sample routes for testing
 def create_sample_route() -> ABRoute:
     """Create a sample route for testing."""
     origin = Coordinates(lat=48.1351, lon=11.5820)  # Munich center
@@ -89,6 +90,11 @@ def create_problematic_route() -> ABRoute:
     return route
 
 
+# =====================================================================
+#  TESTS: AB Route Plausibility Validation
+# =====================================================================
+
+
 def test_good_route_validation() -> None:
     """Test validation of a well-formed route."""
     good_route = create_sample_route()
diff --git a/packages/python/goatlib/tests/unit/routing/test_base_schemas.py b/packages/python/goatlib/tests/unit/routing/test_base_schemas.py
deleted file mode 100644
index 8e2ac8073..000000000
--- a/packages/python/goatlib/tests/unit/routing/test_base_schemas.py
+++ /dev/null
@@ -1,55 +0,0 @@
-from datetime import datetime, timezone
-
-import pytest
-from goatlib.routing.schemas.base import (
-    Coordinates,
-    Mode,
-    Route,
-)
-
-
-@pytest.mark.parametrize(
-    "lat, lon, expected_error",
-    [
-        (91.0, 13.4050, ValueError),
-        (-91.0, 13.4050, ValueError),
-        (52.5200, 181.0, ValueError),
-        (52.5200, -181.0, ValueError),
-    ],
-    ids=["lat-too-high", "lat-too-low", "lon-too-high", "lon-too-low"],
-)
-def test_coordinates_invalid_coordinates(
-    lat: float, lon: float, expected_error: type
-) -> None:
-    """Test that invalid coordinates raise a ValueError."""
-    with pytest.raises(expected_error):
-        Coordinates(lat=lat, lon=lon)
-
-
-def test_coordinates_valid() -> None:
-    """Test creating a valid Coordinates."""
-    coords = Coordinates(lat=52.5200, lon=13.4050)
-    assert coords.lat == 52.5200
-    assert coords.lon == 13.4050
-
-
-def test_transport_mode_enum() -> None:
-    """Test that Mode enum has expected values."""
-    assert Mode.walk == "walk"
-    assert Mode.bus == "bus"
-    assert Mode.car == "car"
-    assert Mode.transit == "transit"
-
-
-# add a test for route schema
-def test_route_schema() -> None:
-    """Test creating a Route object."""
-    route = Route(
-        duration=3600,
-        distance=10000,
-        departure_time=datetime.now(timezone.utc),
-    )
-    assert route.duration == 3600
-    assert route.distance == 10000
-    assert route.departure_time is not None
-    assert route.route_id is not None
diff --git a/packages/python/goatlib/tests/unit/routing/test_catchment_area_transit.py b/packages/python/goatlib/tests/unit/routing/test_catchment_area_schemas.py
similarity index 100%
rename from packages/python/goatlib/tests/unit/routing/test_catchment_area_transit.py
rename to packages/python/goatlib/tests/unit/routing/test_catchment_area_schemas.py