xplan-tools 1.12.0__py3-none-any.whl → 1.13.0__py3-none-any.whl

xplan_tools/interface/__init__.py

@@ -24,9 +24,6 @@ logger = logging.getLogger(__name__)
 def repo_factory(
     datasource: str = "",
     repo_type: Literal["gml", "jsonfg", "shape", "db"] | None = None,
-    schema: str | None = None,
-    srid: int = 25832,
-    views: bool = False,
 ) -> "BaseRepository":
     """Factory method for Repositories.
 
@@ -111,7 +108,7 @@ def repo_factory(
         case "db":
             logger.debug("initializing DB repository")
             return locate("xplan_tools.interface.db.DBRepository")(
-                datasource, schema, srid, views
+                datasource,
             )
         case _:
             raise ValueError("Unknown datasource")

xplan_tools/interface/db.py

@@ -3,7 +3,7 @@
 # import json
 import logging
 from pathlib import Path
-from typing import Iterable
+from typing import Iterable, Literal
 
 from alembic import command, config, script
 from geoalchemy2 import load_spatialite_gpkg
@@ -32,7 +32,7 @@ from sqlalchemy.orm import sessionmaker
 from xplan_tools.model import model_factory
 from xplan_tools.model.base import BaseCollection, BaseFeature
 from xplan_tools.model.orm import Base, Feature, Geometry, Refs
-from xplan_tools.util import check_schema_accessibility
+from xplan_tools.settings import get_settings
 
 # from xplan_tools.util import linearize_geom
 from .base import BaseRepository
@@ -46,9 +46,6 @@ class DBRepository(BaseRepository):
     def __init__(
         self,
         datasource: str = "",
-        schema: str | None = None,
-        srid: int = 25832,
-        with_views: bool = False,
     ) -> None:
         """Initializes the DB Repository.
 
@@ -59,40 +56,89 @@ class DBRepository(BaseRepository):
 
         Args:
             datasource: A connection string which will be transformed to a URL instance.
-            schema: Schema name for DB repository. If not specified, the default schema is used. Only for PostgreSQL.
-            srid: the EPSG code for spatial data
-            with_views: whether to create geometrytype-specific views (postgres only)
         """
+        settings = get_settings()
         self.datasource: URL = make_url(datasource)
         self.content = None
-        self.schema = schema
+        self.schema = settings.db_schema
+        self.srid = settings.db_srid
         self.dialect = self.datasource.get_dialect().name
         self.Session = sessionmaker(bind=self._engine)
-        # self.session = self.Session()
-        self.srid = srid
-        self.with_views = with_views
 
         self.alembic_cfg = config.Config()
         self.alembic_cfg.set_main_option(
             "script_location", "xplan_tools:model:migrations"
         )
-        self.alembic_cfg.set_main_option("srid", str(srid))
-        if with_views:
-            self.alembic_cfg.set_main_option("with_views", "1")
         self.alembic_cfg.set_main_option(
             "sqlalchemy.url",
             datasource.replace("gpkg:", "sqlite:").replace(
                 "postgresql:", "postgresql+psycopg:"
             ),
         )
-        if self.schema and self.dialect == "postgresql":
-            check_schema_accessibility(self._engine, self.schema)
-            self.alembic_cfg.set_main_option("custom_schema", self.schema)
+        self._ensure_repo()
+
+    def _ensure_repo(self) -> None:
+        """Runs initial connection/schema tests and ensures DB revision."""
+
+        def _check_schema_accessibility(privilege: Literal["USAGE", "CREATE"]) -> None:
+            """Raises an exception if the schema does not exist or is not accessible to the current user."""
+            # Check if the schema exists and is accessible
+            user = conn.execute(text("SELECT current_user")).scalar()
+            result = conn.execute(
+                text("""
+                    SELECT has_schema_privilege(:user, :schema, :privilege)
+                """),
+                {
+                    "user": user,
+                    "schema": self.schema,
+                    "privilege": privilege,
+                },
+            )
+            if not result.scalar():
+                raise RuntimeError(
+                    f"User {user} lacks {privilege} on schema '{self.schema}'"
+                )
+
+        def _check_db_srid() -> None:
+            """Raises an exception if the DB SRID differs from the one of the repo."""
+            if self.dialect == "geopackage":
+                geometry_columns = Table(
+                    "gpkg_geometry_columns",
+                    MetaData(),
+                    Column("table_name"),
+                    Column("srs_id"),
+                )
+                stmt = select(geometry_columns.c.srs_id).where(
+                    geometry_columns.c.table_name == "coretable"
+                )
+            else:
+                geometry_columns = Table(
+                    "geometry_columns",
+                    MetaData(),
+                    Column("f_table_name"),
+                    Column("srid"),
+                )
+                stmt = select(geometry_columns.c.srid).where(
+                    geometry_columns.c.f_table_name == "coretable"
+                )
+                if self.dialect == "postgresql":
+                    geometry_columns.append_column(Column("f_table_schema"))
+                    stmt = stmt.where(
+                        geometry_columns.c.f_table_schema == (self.schema or "public")
+                    )
+            srid = conn.execute(stmt).scalar_one()
+            if srid != self.srid:
+                raise RuntimeError(
+                    f"DB SRID '{srid}' and configured SRID '{self.srid}' must identical"
+                )
+
         current_version = script.ScriptDirectory.from_config(
             self.alembic_cfg
         ).get_heads()
         # test for tables and revision
         with self._engine.connect() as conn:
+            if self.schema and self.dialect == "postgresql":
+                _check_schema_accessibility("USAGE")
             inspector = inspect(conn)
             tables = inspector.get_table_names(schema=self.schema)
             is_coretable = {"coretable", "refs"}.issubset(set(tables))
@@ -106,10 +152,14 @@ class DBRepository(BaseRepository):
                 db_version = conn.execute(stmt).scalars().all()
             else:
                 db_version = []
+            if db_version:
+                _check_db_srid()
             is_current_version = set(db_version) == set(current_version)
             if is_current_version:
                 logger.info("Database is at current revision")
                 return
+            elif self.schema and self.dialect == "postgresql":
+                _check_schema_accessibility("CREATE")
         # handle schema upgrade or table creation
         if is_coretable and not db_version:
             e = RuntimeError("Coretable with no revision found in database")
@@ -140,7 +190,7 @@ class DBRepository(BaseRepository):
         else:
             # create tables if it's a fresh file-based DB and set it to current revision
             logger.info("Creating new database schema")
-            self.create_tables(self.srid)
+            self.create_tables()
             command.stamp(self.alembic_cfg, "head")
 
     @property
@@ -151,8 +201,10 @@ class DBRepository(BaseRepository):
             else self.datasource
         )
         connect_args: dict[str, str] = {}
-        if self.schema and self.dialect == "postgresql":
-            connect_args["options"] = f"-csearch_path={self.schema},public"
+        if self.dialect == "postgresql":
+            connect_args["connect_timeout"] = 5
+            if self.schema:
+                connect_args["options"] = f"-csearch_path={self.schema},public"
         engine = create_engine(url, connect_args=connect_args)
         if self.dialect == "geopackage":
             listen(engine, "connect", load_spatialite_gpkg)
@@ -315,7 +367,7 @@ class DBRepository(BaseRepository):
             else:
                 raise ValueError(f"no feature found with id {id}")
 
-    def create_tables(self, srid: int) -> None:
+    def create_tables(self) -> None:
         """Creates coretable and related/spatial tables in the database.
 
         Args:
@@ -326,7 +378,7 @@ class DBRepository(BaseRepository):
         def pre_creation(_, conn, **kwargs):
             if self.dialect == "sqlite":
                 conn.execute(text("SELECT InitSpatialMetaData('EMPTY')"))
-                conn.execute(text("SELECT InsertEpsgSrid(:srid)"), {"srid": srid})
+                conn.execute(text("SELECT InsertEpsgSrid(:srid)"), {"srid": self.srid})
 
         @listens_for(Base.metadata, "after_create")
         def post_creation(_, conn, **kwargs):
@@ -362,7 +414,7 @@ class DBRepository(BaseRepository):
                     )
                 )
 
-        logger.debug(f"creating tables with srid {srid}")
+        logger.debug(f"creating tables with srid {self.srid}")
         tables = Base.metadata.sorted_tables
         if not self.dialect == "geopackage":
             tables.pop(1)
@@ -370,7 +422,7 @@ class DBRepository(BaseRepository):
             Column(
                 "geometry",
                 Geometry(
-                    srid=srid,
+                    srid=self.srid,
                     spatial_index=True,
                 ),
                 nullable=True,

xplan_tools/interface/gml.py

@@ -56,6 +56,13 @@ class GMLRepository(BaseRepository):
             ),
         ):
             return "xtrasse"
+        elif re.search(
+            "http://www[.]xwaermeplan[.]de/[0-9]/[0-9]",
+            self.content.get(
+                f"{{{xsi}}}schemaLocation", self.content.nsmap.get(None, "")
+            ),
+        ):
+            return "xwp"
         elif self.content.nsmap.get(
             "xplan", self.content.nsmap.get(None, "")
         ) or re.search(
@@ -73,6 +80,11 @@ class GMLRepository(BaseRepository):
         if self.appschema == "xtrasse":
             uri = self.content.nsmap.get("xtrasse", self.content.nsmap.get(None, ""))
             return uri.split("http://www.xtrasse.de/")[1].replace("/", ".")
+        elif self.appschema == "xwp":
+            uri = self.content.nsmap.get(
+                "xwaermeplan", self.content.nsmap.get(None, "")
+            )
+            return uri.split("http://www.xwaermeplan.de/")[1].replace("/", ".")
         else:
             uri = self.content.nsmap.get("xplan", self.content.nsmap.get(None, ""))
             if "xplan" not in uri:
@@ -149,6 +161,24 @@ class GMLRepository(BaseRepository):
                 },
                 nsmap=nsmap,
             )
+        elif self.appschema == "xwp":
+            nsmap = {
+                None: f"http://www.xwaermeplan.de/{self.version.replace('.', '/')}",
+                "gml": "http://www.opengis.net/gml/3.2",
+                "xml": "http://www.w3.org/XML/1998/namespace",
+                "xlink": "http://www.w3.org/1999/xlink",
+                "xsi": "http://www.w3.org/2001/XMLSchema-instance",
+                "sf": "http://www.opengis.net/ogcapi-features-1/1.0/sf",
+            }
+
+            root = etree.Element(
+                "{http://www.opengis.net/ogcapi-features-1/1.0/sf}FeatureCollection",
+                attrib={
+                    "{http://www.w3.org/2001/XMLSchema-instance}schemaLocation": f"{nsmap[None]} https://gitlab.opencode.de/xleitstelle/xwaermeplan/spezifikation/-/raw/main/xsd/waermeplan.xsd {nsmap['sf']} http://schemas.opengis.net/ogcapi/features/part1/1.0/xml/core-sf.xsd {nsmap['gml']} https://schemas.opengis.net/gml/3.2.1/gml.xsd",
+                    "{http://www.opengis.net/gml/3.2}id": f"GML_{uuid4()}",
+                },
+                nsmap=nsmap,
+            )
 
         elif self.appschema == "plu":
             nsmap = {
@@ -173,12 +203,14 @@ class GMLRepository(BaseRepository):
                 nsmap=nsmap,
             )
 
-        if self.appschema != "xtrasse":
+        if self.appschema not in ["xtrasse", "xwp"]:
             bounds = etree.SubElement(
                 root,
-                "{http://www.opengis.net/gml/3.2}boundedBy"
-                if self.appschema == "xplan"
-                else "{http://www.opengis.net/wfs/2.0}boundedBy",
+                (
+                    "{http://www.opengis.net/gml/3.2}boundedBy"
+                    if self.appschema == "xplan"
+                    else "{http://www.opengis.net/wfs/2.0}boundedBy"
+                ),
             )
 
         geoms = []
@@ -193,11 +225,15 @@ class GMLRepository(BaseRepository):
                     srs = feature.get_geom_srid()
                 etree.SubElement(
                     root,
-                    "{http://www.opengis.net/gml/3.2}featureMember"
-                    if self.appschema == "xplan"
-                    else "{http://www.opengis.net/ogcapi-features-1/1.0/sf}featureMember"
-                    if self.appschema == "xtrasse"
-                    else "{http://www.opengis.net/wfs/2.0}member",
+                    (
+                        "{http://www.opengis.net/gml/3.2}featureMember"
+                        if self.appschema == "xplan"
+                        else (
+                            "{http://www.opengis.net/ogcapi-features-1/1.0/sf}featureMember"
+                            if self.appschema in ["xtrasse", "xwp"]
+                            else "{http://www.opengis.net/wfs/2.0}member"
+                        )
+                    ),
                 ).append(
                     feature.model_dump_gml(feature_srs=kwargs.get("feature_srs", True))
                 )
@@ -210,7 +246,7 @@ class GMLRepository(BaseRepository):
             else {"srsName": f"EPSG:{srs}"}
         )
 
-        if self.appschema != "xtrasse":
+        if self.appschema not in ["xtrasse", "xwp"]:
             envelope = etree.SubElement(
                 bounds,
                 "{http://www.opengis.net/gml/3.2}Envelope",

xplan_tools/interface/jsonfg.py

@@ -91,6 +91,8 @@ class JsonFGRepository(BaseRepository):
             raise ValueError("JSON Schema not found in links")
         if "https://gitlab.opencode.de/xleitstelle/xtrasse/spezifikation" in uri:
             return "xtrasse"
+        elif "https://gitlab.opencode.de/xleitstelle/xwaermeplan/spezifikation/" in uri:
+            return "xwp"
         elif "https://gitlab.opencode.de/xleitstelle/xplanung/schemas/json" in uri:
             return "xplan"
         else:
@@ -107,9 +109,18 @@ class JsonFGRepository(BaseRepository):
             raise ValueError("JSON Schema not found in links")
         if self.appschema == "xtrasse":
             return "2.0"
+        elif self.appschema == "xwp":
+            return "0.9"
         return re.search(r"(.*\/)(\d.\d)(\/.*)", uri).group(2)
 
     def _collection_template(self, srid: int, featuretype: str | None = None):
+        match self.appschema:
+            case "xtrasse":
+                href = "https://gitlab.opencode.de/xleitstelle/xtrasse/spezifikation/-/raw/main/json/featurecollection.json"
+            case "xwp":
+                href = f"https://gitlab.opencode.de/xleitstelle/xwaermeplan/spezifikation/-/raw/main/json/{self.version}/featurecollection.json"
+            case "xplan":
+                href = f"https://gitlab.opencode.de/xleitstelle/xplanung/schemas/json/-/raw/main/{self.version}/featurecollection.json"
         template = {
             "type": "FeatureCollection",
             "featureType": featuretype,
@@ -117,9 +128,7 @@ class JsonFGRepository(BaseRepository):
             "features": [],
             "links": [
                 {
-                    "href": "https://gitlab.opencode.de/xleitstelle/xtrasse/spezifikation/-/raw/main/json/featurecollection.json"
-                    if self.appschema == "xtrasse"
-                    else f"https://gitlab.opencode.de/xleitstelle/xplanung/schemas/json/-/raw/main/{self.version}/featurecollection.json",
+                    "href": href,
                     "rel": "describedby",
                     "type": "application/schema+json",
                     "title": "JSON Schema of this document",

xplan_tools/main.py

@@ -13,6 +13,7 @@ from rich.logging import RichHandler
 from rich.traceback import Traceback
 
 from xplan_tools.interface import repo_factory
+from xplan_tools.settings.settings import get_settings
 from xplan_tools.transform import transformer_factory
 from xplan_tools.util import MigrationPath, _Versions, serialize_style_rules
 from xplan_tools.util.validate import xplan_validate
@@ -25,6 +26,8 @@ logger = logging.getLogger(__name__)
 # don't propagate alembic logs when using CLI
 logging.getLogger("alembic").propagate = False
 
+settings = get_settings()
+
 app = typer.Typer(help=f"XPlan-Tools {__version__}")
 db_app = typer.Typer()
 app.add_typer(
@@ -335,13 +338,16 @@ def create_schema(
     ] = 25832,
     views: Annotated[
         bool, typer.Option(help="Whether to create views for geometry types.")
-    ] = False,
+    ] = True,
     schema: Annotated[
         str | None, typer.Option(help="Whether to specify a schema.")
     ] = None,
 ):
     """Create Coretable schema in the given DB."""
-    repo_factory(connection_string, schema=schema, srid=srid, views=views)
+    settings.db_schema = schema
+    settings.db_srid = srid
+    settings.db_views = views
+    repo_factory(connection_string)
     console.log("Schema created.")
 
 
@@ -355,7 +361,8 @@ def drop_schema(
     ] = None,
 ):
     """Drop Coretable schema in the given DB."""
-    repo_factory(connection_string, schema=schema).delete_tables()
+    settings.db_schema = schema
+    repo_factory(connection_string).delete_tables()
     console.log("Schema dropped.")
 
 

xplan_tools/model/__init__.py

@@ -27,14 +27,17 @@ Example:
 from pydoc import locate
 from typing import TYPE_CHECKING, Literal, Type
 
+from deprecated import deprecated
+
 if TYPE_CHECKING:
     from .base import BaseFeature
 
 
+@deprecated(reason="use Appschema.model_factory instead")
 def model_factory(
     model_name: str,
     model_version: str | None,
-    appschema: Literal["xplan", "xtrasse", "plu", "def"] = "xplan",
+    appschema: Literal["xplan", "xtrasse", "xwp", "plu", "def"] = "xplan",
 ) -> Type["BaseFeature"]:
     """Factory method for retrieving the corresponding pydantic model representation of a feature class.
 
@@ -75,6 +78,10 @@ def model_factory(
             model = locate(
                 f"xplan_tools.model.appschema.xtrasse{model_version.replace('.', '')}.{model_name.replace('_', '')}"
             )
+        case "xwp":
+            model = locate(
+                f"xplan_tools.model.appschema.xwp{model_version.replace('.', '')}.{model_name.replace('_', '')}"
+            )
 
     if not model:
         raise ValueError(

xplan_tools/model/adapters/gml.py

@@ -24,9 +24,14 @@ class GMLAdapter:
 
         def parse_property(name, value, index: int | None = None):
             gml_name = f"{{{ns}}}{name}"
-
             if name == "id":
                 feature.set("{http://www.opengis.net/gml/3.2}id", f"GML_{value}")
+                if self.get_appschema() != "plu":
+                    etree.SubElement(
+                        feature,
+                        "{http://www.opengis.net/gml/3.2}identifier",
+                        attrib={"codeSpace": "urn:uuid"},
+                    ).text = value
                 return
             # Patch for vertikaleDifferenzierung being optional with a default value of False instead of None
             if name == "vertikaleDifferenzierung" and value is False:
@@ -59,9 +64,11 @@ class GMLAdapter:
                                     options=[
                                         "FORMAT=GML32",
                                         f"GMLID=GML_{uuid4()}",
-                                        "SRSNAME_FORMAT=OGC_URL"
-                                        if self.get_appschema() == "plu"
-                                        else "GML3_LONGSRS=NO",
+                                        (
+                                            "SRSNAME_FORMAT=OGC_URL"
+                                            if self.get_appschema() == "plu"
+                                            else "GML3_LONGSRS=NO"
+                                        ),
                                         "NAMESPACE_DECL=YES",
                                     ]
                                 )

xplan_tools/model/appschema/definitions.py

@@ -1,5 +1,6 @@
 # generated from JSON Schema
 
+
 from __future__ import annotations
 
 from datetime import date as date_aliased
@@ -42,86 +43,56 @@ class MultiPoint(GeometryBase):
     wkt: Annotated[str, Field(pattern="^(MULTIPOINT).*$")]
 
 
-class XPPunktgeometrie(RootModel[Point | MultiPoint]):
-    root: Point | MultiPoint
-
-
-class XPLiniengeometrie(RootModel[Line | MultiLine]):
-    root: Line | MultiLine
-
-
-class XPFlaechengeometrie(RootModel[Polygon | MultiPolygon]):
-    root: Polygon | MultiPolygon
-
-
 class Measure(BaseFeature):
-    """
-    Basisklasse für Maße
-    """
+    """Basisklasse für Maße"""
 
     value: Annotated[float, Field(description="Wert des Maßes")]
 
 
 class Length(Measure):
-    """
-    Angabe einer Länge in Metern
-    """
+    """Angabe einer Länge in Metern"""
 
     uom: Annotated[str | None, Field(description="Maßeinheit")] = "m"
 
 
 class Area(Measure):
-    """
-    Angabe einer Fläche in Quadratmetern
-    """
+    """Angabe einer Fläche in Quadratmetern"""
 
     uom: Annotated[str | None, Field(description="Maßeinheit")] = "m2"
 
 
 class Angle(Measure):
-    """
-    Angabe eines Winkels in Grad
-    """
+    """Angabe eines Winkels in Grad"""
 
     uom: Annotated[str | None, Field(description="Maßeinheit")] = "grad"
 
 
 class Volume(Measure):
-    """
-    Angabe eines Volumens in Kubikmetern
-    """
+    """Angabe eines Volumens in Kubikmetern"""
 
     uom: Annotated[str | None, Field(description="Maßeinheit")] = "m3"
 
 
-class Scale(Measure):
-    """
-    Angabe einer Skala in Prozent
-    """
+class Velocity(Measure):
+    """Angabe einer Geschwindigkeit in km/h"""
 
-    uom: Annotated[str | None, Field(description="Maßeinheit")] = "vH"
+    uom: Annotated[str | None, Field(description="Maßeinheit")] = "km/h"
 
 
-class Velocity(Measure):
-    """
-    Angabe einer Geschwindigkeit in Kilometern pro Stunde
-    """
+class Scale(Measure):
+    """Angabe einer Skala in Prozent"""
 
-    uom: Annotated[str | None, Field(description="Maßeinheit")] = "km/h"
+    uom: Annotated[str | None, Field(description="Maßeinheit")] = "vH"
 
 
 class GenericMeasure(Measure):
-    """
-    Nicht näher konkretisiertes Maß
-    """
+    """Nicht näher konkretisiertes Maß"""
 
-    uom: Annotated[str | None, Field(description="Maßeinheit")] = "tbd"
+    uom: Annotated[str | None, Field(description="Maßeinheit")] = "unknown"
 
 
 class VoidReasonValue(BaseFeature):
-    """
-    Reasons for void values.
-    """
+    """Reasons for void values."""
 
     nilReason: Annotated[AnyUrl, Field(description="Reason")]