Use wkb element geography for coordinates

.github/workflows/ci.yml

@@ -88,6 +88,12 @@ jobs:
       #    run test suite
       #----------------------------------------------
       - name: Run tests
+        if: matrix.os != 'windows-latest'
         run: |
           source $VENV
           pytest tests/
+      - name: Run tests (Windows - skip Docker tests)
+        if: matrix.os == 'windows-latest'
+        run: |
+          source $VENV
+          pytest tests/ -m "not docker_required"

CHANGELOG.md

@@ -19,7 +19,8 @@ All notable changes to this project will be documented in this file.
 - Adapt to recent PSDM changes with regard to energy management systems [#164](https://github.com/ie3-institute/pypsdm/issue/164)
 - Removed node from create method of energy management systems [#267](https://github.com/ie3-institute/pypsdm/issue/267)
 - Changed default value for `cos_Phi` of create method of `ElectricVehicleChargingStations` to 1.0 [#272](https://github.com/ie3-institute/pypsdm/issue/272) 
-- Fix `create_grid` notebook to PSDM changes with respect to Em [#281](https://github.com/ie3-institute/pypsdm/issues/281) 
+- Fix `create_grid` notebook to PSDM changes with respect to Em [#281](https://github.com/ie3-institute/pypsdm/issues/281)
+- Adapt Coordinate type to use WKBElement Geography [#287](https://github.com/ie3-institute/pypsdm/issues/287)
 
 ### Removed
 

nbs/create_grid.ipynb

@@ -66,7 +66,11 @@
    "source": [
     "from pypsdm.models.input.create.participants import create_energy_management_systems\n",
     "\n",
-    "em_uuids = [\"74d45b31-c35b-403b-96ac-5210754eb4de\",\"093e03ee-2d38-4e91-9f44-c71d92c07d89\",\"22af972d-19a8-415d-8c0a-50fa1238a7d9\"]\n",
+    "em_uuids = [\n",
+    "    \"74d45b31-c35b-403b-96ac-5210754eb4de\",\n",
+    "    \"093e03ee-2d38-4e91-9f44-c71d92c07d89\",\n",
+    "    \"22af972d-19a8-415d-8c0a-50fa1238a7d9\",\n",
+    "]\n",
     "\n",
     "data_dict = {\n",
     "    \"uuid\": em_uuids,\n",

pyproject.toml

@@ -26,6 +26,7 @@ sqlmodel = "^0.0.24"
 pyhocon = "^0.3.60"
 psycopg2 = "^2.9.9"
 numba = "^0.61.0"
+geoalchemy2 = "^0.17.1"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.3.5"

pypsdm/db/weather/models.py

@@ -1,9 +1,12 @@
 import binascii
 from datetime import datetime
-from typing import Optional
+from typing import Any, ClassVar, Dict
 
+from geoalchemy2 import Geometry, WKBElement
 from shapely import Point
-from shapely.wkb import loads
+from shapely.geometry.base import BaseGeometry
+from shapely.wkb import dumps, loads
+from sqlalchemy import Column
 from sqlmodel import Field, SQLModel
 
 
@@ -12,10 +15,8 @@ class WeatherValue(SQLModel, table=True):
     Represents the ICON weather model.
     """
 
-    time: Optional[datetime] = Field(primary_key=True)
-    coordinate_id: Optional[int] = Field(
-        primary_key=True, default=None, foreign_key="coordinate.id"
-    )
+    time: datetime = Field(primary_key=True)
+    coordinate_id: int = Field(primary_key=True, foreign_key="coordinate.id")
     aswdifd_s: float = Field()
     aswdir_s: float = Field()
     t2m: float = Field()
@@ -57,20 +58,37 @@ def name_mapping():
 
 
 class Coordinate(SQLModel, table=True):
-    id: int = Field(primary_key=True)
-    coordinate: str = Field()
+    """Represents a geographical coordinate."""
+
+    model_config: ClassVar[Dict[str, Any]] = {"arbitrary_types_allowed": True}
+
+    id: int = Field(default=None, primary_key=True)
+
+    # Use Geometry for storing WKB data (binary format)
+    coordinate: WKBElement = Field(
+        sa_column=Column(
+            Geometry(geometry_type="POINT", srid=4326, from_text="ST_GeomFromWKB")
+        )
+    )
+
+    def __init__(self, id: int, coordinate: Geometry):
+        self.id = id
+        self.coordinate = coordinate
 
     def __eq__(self, other):
-        return self.id == other.id
+        return self.id == other.id if isinstance(other, Coordinate) else NotImplemented
 
     def __hash__(self):
         return hash(self.id)
 
     @property
-    def point(self) -> Point:
-        wkb_str = self.coordinate
-        wkb_bytes = binascii.unhexlify(wkb_str)
-        return loads(wkb_bytes)
+    def point(self) -> BaseGeometry:
+        if isinstance(self.coordinate, WKBElement):
+            wkb_str = str(self.coordinate)
+            coordinate = bytes.fromhex(wkb_str)
+        else:
+            coordinate = self.coordinate
+        return loads(coordinate)
 
     @property
     def latitude(self) -> float:
@@ -89,6 +107,12 @@ def x(self) -> float:
         return self.point.x
 
     @staticmethod
-    def from_xy(id, x, y):
-        wkb = Point(x, y).wkb_hex
-        return Coordinate(id=id, coordinate=wkb)
+    def from_xy(id: int, x: float, y: float) -> "Coordinate":
+        point = Point(x, y)
+        wkb_data = dumps(point)
+        return Coordinate(id=id, coordinate=wkb_data)
+
+    @staticmethod
+    def from_hex(id: int, wkb_hex: str) -> "Coordinate":
+        bytes = binascii.unhexlify(wkb_hex)
+        return Coordinate(id=id, coordinate=bytes)

tests/db/weather/conftest.py

@@ -0,0 +1,109 @@
+import subprocess
+import time
+
+import pytest
+import sqlalchemy
+from sqlalchemy import text
+from sqlmodel import Session, SQLModel, create_engine
+
+
+@pytest.fixture(scope="session")
+@pytest.mark.docker_required
+def docker_postgres():
+    """Start a PostgreSQL container for testing."""
+    container_name = "test_weather"
+
+    # Check if the container already exists
+    check_cmd = [
+        "docker",
+        "ps",
+        "-a",
+        "--filter",
+        f"name={container_name}",
+        "--format",
+        "{{.Names}}",
+    ]
+    result = subprocess.run(check_cmd, capture_output=True, text=True)
+
+    if container_name in result.stdout:
+        # Remove existing container
+        subprocess.run(["docker", "rm", "-f", container_name], check=True)
+
+    # Start a new container
+    run_cmd = [
+        "docker",
+        "run",
+        "--name",
+        container_name,
+        "-e",
+        "POSTGRES_USER=postgres",
+        "-e",
+        "POSTGRES_PASSWORD=postgres",
+        "-e",
+        "POSTGRES_DB=test_weather",
+        "-p",
+        "5433:5432",
+        "-d",
+        "postgis/postgis:17-3.4",
+    ]
+    subprocess.run(run_cmd, check=True)
+
+    # Wait for the database to be ready
+    time.sleep(5)
+
+    yield "postgresql://postgres:postgres@localhost:5433/test_weather"
+
+    # Cleanup
+    subprocess.run(["docker", "rm", "-f", container_name], check=True)
+
+
+@pytest.fixture(scope="session")
+@pytest.mark.docker_required
+def db_engine(docker_postgres):
+    """Create a database engine connected to the Docker PostgreSQL instance."""
+    engine = create_engine(docker_postgres)
+
+    # Try connecting multiple times with increasing delays
+    max_retries = 5
+    retry_delay = 1  # seconds
+
+    for attempt in range(max_retries):
+        try:
+            # Enable PostGIS
+            with engine.connect() as conn:
+                conn.execute(text("CREATE EXTENSION IF NOT EXISTS postgis;"))
+                conn.commit()
+
+            SQLModel.metadata.create_all(engine)
+            break
+
+        except sqlalchemy.exc.OperationalError as e:
+            if attempt < max_retries - 1:
+                print(
+                    f"Connection attempt {attempt + 1} failed. Retrying in {retry_delay}s..."
+                )
+                time.sleep(retry_delay)
+                retry_delay *= 2  # Exponential backoff
+            else:
+                raise Exception(
+                    f"Failed to connect after {max_retries} attempts"
+                ) from e
+
+    return engine
+
+
+@pytest.fixture
+@pytest.mark.docker_required
+def db_session(db_engine):
+    """Create a new database session for a test."""
+    with Session(db_engine) as session:
+        yield session
+        session.rollback()  # Rollback after each test
+
+
+@pytest.fixture(scope="function", autouse=True)
+@pytest.mark.docker_required
+def reset_db(db_engine):
+    """Drop and recreate all tables before each test."""
+    SQLModel.metadata.drop_all(db_engine)
+    SQLModel.metadata.create_all(db_engine)

tests/db/weather/docker_compose.yml

@@ -0,0 +1,22 @@
+version: '3'
+
+services:
+  postgis:
+    image: postgis/postgis:17-3.4
+    container_name: test_weather
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=test_weather
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    ports:
+      - "5433:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  pgdata:

tests/db/weather/test_proxy.py

@@ -1,64 +1,67 @@
 import math
 
+import pytest
+
 from pypsdm.db.weather.models import Coordinate
 from pypsdm.db.weather.utils import weighted_interpolation_coordinates
 
 
+@pytest.mark.docker_required
 def test_weighted_interpolation_coordinates():
     nearest_coordinates = [
         (
-            Coordinate(
+            Coordinate.from_hex(
                 id=13890,
-                coordinate="0101000020E610000000000000008026400000000000E04A40",
+                wkb_hex="0101000020E610000000000000008026400000000000E04A40",
             ),
             15336.967985536437,
         ),
         (
-            Coordinate(
+            Coordinate.from_hex(
                 id=13891,
-                coordinate="0101000020E610000000000000000027400000000000E04A40",
+                wkb_hex="0101000020E610000000000000000027400000000000E04A40",
             ),
             15741.508288878984,
         ),
         (
-            Coordinate(
+            Coordinate.from_hex(
                 id=14079,
-                coordinate="0101000020E610000000000000008026400000000000C04A40",
+                wkb_hex="0101000020E610000000000000008026400000000000C04A40",
             ),
             16606.405396805483,
         ),
         (
-            Coordinate(
+            Coordinate.from_hex(
                 id=14080,
-                coordinate="0101000020E610000000000000000027400000000000C04A40",
+                wkb_hex="0101000020E610000000000000000027400000000000C04A40",
             ),
             16982.92952636213,
         ),
         (
-            Coordinate(
+            Coordinate.from_hex(
                 id=13889,
-                coordinate="0101000020E610000000000000000026400000000000E04A40",
+                wkb_hex="0101000020E610000000000000000026400000000000E04A40",
             ),
             27650.80452994915,
         ),
         (
-            Coordinate(
+            Coordinate.from_hex(
                 id=13892,
-                coordinate="0101000020E610000000000000008027400000000000E04A40",
+                wkb_hex="0101000020E610000000000000008027400000000000E04A40",
             ),
             28324.62399357631,
         ),
         (
-            Coordinate(
+            Coordinate.from_hex(
                 id=14078,
-                coordinate="0101000020E610000000000000000026400000000000C04A40",
+                wkb_hex="0101000020E610000000000000000026400000000000C04A40",
             ),
             28429.952194089583,
         ),
         (
-            Coordinate(
+            Coordinate.from_hex(
                 id=14081,
-                coordinate="0101000020E610000000000000008027400000000000C04A40",
+                wkb_hex="0101000020E610000000000000008027400000000000C04A40",
             ),
             29089.579082292785,
         ),

tests/db/weather/test_utils.py

@@ -1,7 +1,10 @@
+import pytest
+
 from pypsdm.db.weather.models import Coordinate
 from pypsdm.db.weather.utils import weighted_interpolation_coordinates
 
 
+@pytest.mark.docker_required
 def test_weighted_interpolation_coordinates():
     target = (0, 0)