xmas-app 0.13.1__py3-none-any.whl → 0.14.0__py3-none-any.whl

xmas_app/db.py

@@ -1,77 +1,15 @@
 import logging
 
 from nicegui.observables import ObservableSet
-from sqlalchemy import select, text
-from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy.orm import aliased, selectinload
-from xplan_tools.interface.db import DBRepository
+from sqlalchemy import select
+from sqlalchemy.orm import selectinload
 from xplan_tools.model import model_factory
 from xplan_tools.model.base import BaseFeature
 from xplan_tools.model.orm import Feature, Refs
 
 from xmas_app.settings import get_mappings, get_settings
 
-logger = logging.getLogger(__name__)
-
-
-def get_db_feature_ids(
-    repo: DBRepository,
-    typenames: str | list | None = None,
-    featuretype_regex: str | None = None,
-    value_prop: str | None = None,
-) -> dict:
-    """
-    Query the database for features matching the provided type(s) or regex, and
-    return a mapping from feature IDs to label (from `value_prop`) or a fallback string.
-
-    Args:
-        repo (DBRepository): The database repository instance.
-        typenames (str | list | None): Single typename or list of typenames to filter on.
-        featuretype_regex (str | None): Optional regex to match featuretype.
-        value_prop (str | None): The property to use for the label in the result dict.
-
-    Returns:
-        dict: Mapping from stringified feature ID to label or fallback.
-    """
-    logger.info("Entered db.get_db_feature_ids().")
-    results = {}
-    try:
-        with repo.Session() as session:
-            stmt = select(Feature)
-            if typenames:
-                names_list = [typenames] if isinstance(typenames, str) else typenames
-                stmt = stmt.where(Feature.featuretype.in_(names_list))
-                logger.info(f"Filtering for typenames: {names_list}")
-            if featuretype_regex:
-                stmt = stmt.where(Feature.featuretype.regexp_match(featuretype_regex))
-                logger.info(f"Filtering with regex: {featuretype_regex}")
-            try:
-                db_result = session.execute(stmt)
-                features = db_result.unique().scalars().all()
-                logger.info(f"Found {len(features)} feature(s) in DB.")
-            except Exception as db_ex:
-                logger.error(f"Database query failed: {db_ex}", exc_info=True)
-                return {}
-
-            for feature in features:
-                label = None
-                try:
-                    label = (
-                        feature.properties.get(value_prop, None) if value_prop else None
-                    )
-                except Exception as prop_ex:
-                    logger.warning(
-                        f"Error accessing properties of feature ID {feature.id}: {prop_ex}",
-                        exc_info=True,
-                    )
-                key = str(feature.id)
-                value = label if label else f"{feature.featuretype}::{feature.id}"
-                results[key] = value
-
-    except Exception as ex:
-        logger.error(f"Failed to get feature IDs: {ex}", exc_info=True)
-        raise
-    return results
+logger = logging.getLogger("xmas_app")
 
 
 def get_db_plans() -> list[dict]:
@@ -113,34 +51,11 @@ def get_db_plans() -> list[dict]:
     return results
 
 
-def delete_db_association(base_id: str, related_id: str, repo: DBRepository):
-    try:
-        with repo.Session() as session:
-            stmt = text("""
-                DELETE FROM public.refs
-                WHERE base_id = :base_id AND related_id = :related_id
-            """)
-            try:
-                result = session.execute(
-                    stmt, {"base_id": base_id, "related_id": related_id}
-                )
-                session.commit()
-                logger.info(
-                    f"Deleted {result.rowcount} record(s) from public.refs with base_id={base_id} and related_id={related_id}"
-                )
-                return {"deleted_rows": result.rowcount}
-            except SQLAlchemyError as db_ex:
-                session.rollback()
-                logger.error(f"Database delete failed: {db_ex}", exc_info=True)
-                return {"error": str(db_ex)}
-    except Exception as ex:
-        logger.error(f"Failed to delete association: {ex}", exc_info=True)
-        raise
-
-
 def get_nodes(
     id: str, features_set: ObservableSet
 ) -> tuple[dict, str, str, str] | None:
+    """Build tree nodes for ui.tree element."""
+
     def build_node(feature: Feature, path: str) -> dict:
         features_set.add(feature.id)
         node = {
@@ -280,38 +195,9 @@ def get_ref_candidates(
     rel_inv = model.get_property_info(rel)["assoc_info"]["reverse"]
 
     with get_settings().repo.Session() as session:
-        # collect all plan features while applying WHERE clauses to filter on the DB side
-        Plan = aliased(Feature, name="plan")
-        DirectFeature = aliased(Feature, name="direct_feature")
-        IndirectFeature = aliased(Feature, name="indirect_feature")
-
-        RefPlanDirect = aliased(Refs, name="ref_plan_direct")
-        RefDirectIndirect = aliased(Refs, name="ref_direct_indirect")
-        direct = (
-            select(DirectFeature)
-            .select_from(Plan)
-            .join(RefPlanDirect, RefPlanDirect.base_id == Plan.id)
-            .join(DirectFeature, DirectFeature.id == RefPlanDirect.related_id)
-            .where(Plan.id == plan_id)
-            .where(DirectFeature.featuretype.in_(featuretypes))
-            .where(DirectFeature.id.not_in(refs))
-        )
-
-        indirect = (
-            select(IndirectFeature)
-            .select_from(Plan)
-            .join(RefPlanDirect, RefPlanDirect.base_id == Plan.id)
-            .join(DirectFeature, DirectFeature.id == RefPlanDirect.related_id)
-            .join(RefDirectIndirect, RefDirectIndirect.base_id == DirectFeature.id)
-            .join(IndirectFeature, IndirectFeature.id == RefDirectIndirect.related_id)
-            .where(Plan.id == plan_id)
-            .where(IndirectFeature.featuretype.in_(featuretypes))
-            .where(IndirectFeature.id.not_in(refs))
-        )
-        stmt = direct.union(indirect)
-
-        candidates = (
-            session.execute(select(Feature).from_statement(stmt)).scalars().all()
+        plan = session.get(Feature, plan_id)
+        candidates = plan.related_features(
+            session, featuretypes=featuretypes, exclude_ids=refs
         )
         return [
             _feature_to_table_row(feature)

xmas_app/form.py

@@ -1112,6 +1112,11 @@ class ModelForm:
                                     )
                                     .classes("w-full q-pa-none q-gutter-none")
                                     .props("square filled dense")
+                                    .bind_value(
+                                        bind_obj,
+                                        key,
+                                        backward=lambda x: None if not x else x,
+                                    )
                                 )
                                 targets = await run.io_bound(
                                     self._get_association_targets,
@@ -1132,11 +1137,6 @@ class ModelForm:
                                     input.set_value(parent_id)
                                 elif len((keys := list(targets.keys()))) == 1:
                                     input.set_value(keys[0])
-                                input.bind_value(
-                                    bind_obj,
-                                    key,
-                                    backward=lambda x: None if not x else x,
-                                )
                                 input.bind_enabled_from(
                                     self,
                                     "editable",
@@ -1222,3 +1222,4 @@ class ModelForm:
                 feature[model_geom] = geom
         self.feature = self._get_bindable_object(self.model)(**feature)
         await self._build_model_form(self.model, self.feature, main_form, preview)
+        self._propagate_data()

xmas_app/main.py

@@ -6,10 +6,11 @@ import logging
 import re
 from contextlib import asynccontextmanager
 from functools import partial
+from importlib import metadata
 from pathlib import Path
 from tempfile import NamedTemporaryFile, gettempdir
-from typing import Any, Literal
-from uuid import uuid4
+from typing import Literal
+from uuid import UUID
 
 import pydantic
 import pydantic_core
@@ -17,7 +18,6 @@ from fastapi import APIRouter, Depends, HTTPException, Request, status
 from nicegui import app, run, ui
 from nicegui.events import ClickEventArguments, ValueChangeEventArguments
 from nicegui.observables import ObservableSet
-from pydantic import ValidationError
 from starlette.applications import Starlette
 from xplan_tools.interface import repo_factory
 from xplan_tools.interface.db import DBRepository
@@ -30,7 +30,7 @@ from xplan_tools.util import (
 )
 
 from xmas_app.components.buttons import FeatureInteractionButton
-from xmas_app.db import get_db_feature_ids, get_db_plans, get_nodes
+from xmas_app.db import get_db_plans, get_nodes
 from xmas_app.deps.version_guard import enforce_plugin_version
 from xmas_app.form import ModelForm
 from xmas_app.models.crud import InsertPayload, UpdatePayload
@@ -39,6 +39,8 @@ from xmas_app.services import crud
 from xmas_app.settings import get_appschema, get_settings
 from xmas_app.split_service import PlanSplitService, SplitValidationError
 
+__version__ = metadata.version("xmas_app")
+
 
 def _resolve_log_dir() -> Path:
     if get_settings().app_mode == "prod":
@@ -108,42 +110,19 @@ async def get_model_for_select(
                     return False
             return True
 
+    options = [
+        model.get_name()
+        for _, model in inspect.getmembers(
+            importlib.import_module(
+                f"xplan_tools.model.appschema.{appschema + appschema_version.replace('.', '')}"
+            ),
+            filter_members,
+        )
+    ]
     # update the input element options
-    model_select.set_options(
-        [
-            model.get_name()
-            for _, model in inspect.getmembers(
-                importlib.import_module(
-                    f"xplan_tools.model.appschema.{appschema + appschema_version.replace('.', '')}"
-                ),
-                filter_members,
-            )
-        ]
-    )
-
-
-@ui.page("/", dependencies=[Depends(enforce_plugin_version)])
-def index():
-    """
-    Render the main index page of the XPlan-GUI application.
-    Args:
-    request (Request): The incoming HTTP request object (FastAPI).
-    """
-    # print(request.headers)
-    ui.colors(primary="rgb(157 157 156)", secondary="rgb(57 92 127)")
-    with ui.header():
-        ui.label("XPlan-GUI")
-    ui.button(
-        "Neues Objekt", on_click=lambda: ui.navigate.to(f"/feature/{str(uuid4())}")
-    )
-    ui.select(
-        dict(
-            sorted(get_db_feature_ids(get_settings().repo).items(), key=lambda x: x[1])
-        ),
-        label="Feature auswählen",
-        with_input=True,
-        on_change=lambda x: ui.navigate.to(f"/feature/{x.value}"),
-    )
+    model_select.set_options(options)
+    if len(options) == 1:
+        model_select.set_value(options[0])
 
 
 @ui.page(
@@ -153,15 +132,21 @@ def index():
 )
 async def plan_tree(
     request: Request,
-    id: str,
+    id: UUID,
 ):
+    id = str(id)
+
     async def update_nodes():
-        result = await get_nodes(feature)
+        result = await run.io_bound(get_nodes, id, app.storage.client["features"])
         if result:
             nodes, *_ = result
-            nodes[0]["children"] = nodes
+            app.storage.client["nodes"] = nodes
             tree.update()
 
+    ui.colors(primary="rgb(157 157 156)", secondary="rgb(57 92 127)")
+    ui.button.default_props("flat square no-caps")
+    ui.button_group.default_props("flat square no-caps")
+
     app.storage.client["user_agent"] = request.headers.get("user-agent", None)
     qgis = app.storage.client["user_agent"].startswith(get_settings().qgis_plugin_name)
     if qgis:
@@ -182,21 +167,6 @@ async def plan_tree(
         ui.separator()
     action_dialog = ui.dialog().on("hide", lambda e: e.sender.clear())
 
-    ui.colors(primary="rgb(157 157 156)", secondary="rgb(57 92 127)")
-    ui.button.default_props("flat square no-caps")
-    ui.button_group.default_props("flat square no-caps")
-
-    # # --- Create the dialog placeholder once ---
-    # with ui.dialog() as confirm_removeAssociation_dialog, ui.card():
-    #     removeAssociation_label = (
-    #         ui.label()
-    #     )  # placeholder text we can update dynamically
-    #     with ui.row().classes("justify-end w-full"):
-    #         cancel_removeAssociation_button = ui.button(
-    #             "Abbrechen", on_click=confirm_removeAssociation_dialog.close
-    #         )
-    #         removeAssociation_confirm_button = ui.button("Aufheben", color="red")
-
     # --- Create the dialog placeholder once ---
     with ui.dialog() as confirm_deleteObject_dialog, ui.card(align_items="stretch"):
         label = ui.label(
@@ -212,16 +182,6 @@ async def plan_tree(
         confirm_button.on("click", partial(delete_feature, target))
         confirm_deleteObject_dialog.open()
 
-    # # --- Function to open the dialog dynamically ---
-    # def confirm_delete_association(origin, target):
-    #     removeAssociation_label.text = f"Möchten Sie diese Beziehung wirklich aufheben?"
-    #     removeAssociation_confirm_button.on(
-    #         "click",
-    #         lambda: remove_association(origin, target),
-    #         confirm_removeAssociation_dialog.close(),
-    #     )
-    #     confirm_removeAssociation_dialog.open()
-
     async def show_menu(e: ValueChangeEventArguments):
         action_dialog.clear()
         if e.value:
@@ -377,9 +337,6 @@ async def plan_tree(
     def update_notification(e):
         notification.message = f"{len(e.sender)} Features geladen"
 
-    if not id:
-        return
-
     await ui.context.client.connected()
     logger.debug("Feature called by ID:")
     logger.debug(id)
@@ -398,8 +355,9 @@ async def plan_tree(
         nodes, featuretype, id, appschema = result
     else:
         return
+    app.storage.client["nodes"] = nodes
     tree = ui.tree(
-        nodes,
+        app.storage.client["nodes"],
         on_select=show_menu,
         tick_strategy=None,
     ).props("accordion no-transition")
@@ -760,13 +718,13 @@ async def plans(
 @ui.page("/feature/{id}", dependencies=[Depends(enforce_plugin_version)])
 async def feature(
     request: Request,
-    id: str,
-    planId: str | None = None,
-    parentId: str | None = None,
+    id: UUID,
+    planId: UUID | None = None,
+    parentId: UUID | None = None,
     featureType: str | None = None,
     featuretypeRegex: str | None = None,
-    appschema: str | None = None,
-    version: str | None = None,
+    appschema: str = get_settings().appschema,
+    version: str = get_settings().appschema_version,
 ):
     """
     Render and manage a single feature view for the XPlan-GUI application.
@@ -797,8 +755,7 @@ async def feature(
     #     form.feature.update(data)
     #     form._get_art_options()
 
-    appschema = appschema or get_settings().appschema
-    version = version or get_settings().appschema_version
+    id = str(id)
 
     async def get_qgis_feature():
         return await ui.run_javascript(
@@ -810,20 +767,6 @@ async def feature(
             timeout=3,
         )
 
-    def validate_feature():
-        form: ModelForm = app.storage.client["form"]
-        if model_instance := form.model_instance:
-            feature_data = model_instance.model_dump(
-                mode="json",
-                exclude_none=True,
-                exclude={form.model.get_geom_field()},
-            ) | {"featuretype": form.model.get_name()}
-            ui.run_javascript(f"""new QWebChannel(qt.webChannelTransport, function (channel) {{
-                                        channel.objects.handler.receive_feature({feature_data})
-                                }});""")
-        else:
-            form.radio_filter.set_value("mandatory")
-
     async def add_form(
         feature_type: str,
         feature: dict,
@@ -885,15 +828,14 @@ async def feature(
 
     ui.colors(primary="rgb(157 157 156)", secondary="rgb(57 92 127)")
     app.storage.client["form"] = None
-    app.storage.client["plan_id"] = planId
-    app.storage.client["parent_id"] = parentId
+    app.storage.client["plan_id"] = str(planId) if planId else None
+    app.storage.client["parent_id"] = str(parentId) if parentId else None
     app.storage.client["user_agent"] = request.headers.get("user-agent", None)
 
     qgis = app.storage.client["user_agent"].startswith(get_settings().qgis_plugin_name)
 
     if qgis:
         ui.add_head_html('<script src="qrc:///qtwebchannel/qwebchannel.js"></script>')
-        ui.on("validateFeature", validate_feature)
 
     try:
         model = get_settings().repo.get(id)
@@ -982,194 +924,22 @@ async def feature(
             await add_form(feature_type, feature)
 
 
-@ui.page("/feature/{id}/associations", dependencies=[Depends(enforce_plugin_version)])
-def get_associations(
-    request: Request,
-    id: str,
-    # wkbType: str | None = None,
-    # planId: str | None = None,
-    # parentId: str | None = None,
-    # editable: bool = True,
-    # featureType: str | None = None,
-    # featuretypeRegex: str | None = None,
-    appschema: str = get_settings().appschema,
-    version: str = get_settings().appschema_version,
-):
-    """
-    Render the associations view for a given feature in the XPlan‑GUI application.
-
-    Args:
-    request (Request): Incoming FastAPI HTTP request object.
-    id (str): Identifier or UUID of the feature whose associations will be displayed.
-    appschema (str): Application schema name (defaults from settings).
-    version (str): Schema version string (defaults from settings).
-    """
-
-    def transfer_feature_data():
-        ui.run_javascript(f"""new QWebChannel(qt.webChannelTransport, function (channel) {{
-                                    channel.objects.handler.handle_feature_creation({feature_data})
-                            }});""")
-
-    def handle_assoc_select(e: ValueChangeEventArguments):
-        stepper.next()
-        feature_data["source"] = {
-            "property": e.value,
-            "value": feature[e.value],
-            "list": model.get_property_info(e.value)["list"],
-        }
-        prop_info = model.get_property_info(e.value)
-        types = prop_info["typename"]
-        type_select.set_options(types if isinstance(types, list) else [types])
-        if isinstance(types, str):
-            type_select.set_value(types)
-
-    def handle_geom_select(geom_regex: str):
-        feature_data["geom_regex"] = geom_regex
-        transfer_feature_data()
-
-    def handle_type_select(e: ValueChangeEventArguments):
-        featuretype = e.value
-        feature_data["featuretype"] = featuretype
-        source_prop = prop_select.value
-        target_model = model_factory(featuretype, version, appschema)
-        if (assoc_info := model.get_property_info(source_prop)["assoc_info"]) and (
-            target_prop := assoc_info["reverse"]
-        ):
-            target_prop_info = target_model.get_property_info(target_prop)
-            feature_data[target_prop] = [id] if target_prop_info["list"] else id
-        geom_types = target_model.get_geom_types()
-        if not geom_types:
-            transfer_feature_data()
-        else:
-            geom_required = not target_model.get_property_info(
-                target_model.get_geom_field()
-            )["nullable"]
-            type_regex_mapping = {
-                geom_type.get_name(): geom_type.model_fields["wkt"].metadata[0].pattern
-                for geom_type in geom_types
-            }
-            if not geom_required:
-                type_regex_mapping["Keine Geometrie"] = "NOGEOMETRY"
-            if len(geom_types) == 1 and geom_required:
-                feature_data["geom_regex"] = list(type_regex_mapping.values())[0]
-                transfer_feature_data()
-            else:
-                with stepper:
-                    with ui.step("Geometrieart auswählen") as geom_step:
-                        ui.label("Geometrieart des neuen Features auswählen")
-                        ui.radio(
-                            {
-                                geom_type: geom_type.replace("PolygonObject", "Fläche")
-                                .replace("PointObject", "Punkt")
-                                .replace("LineObject", "Linie")
-                                for geom_type in type_regex_mapping.keys()
-                            },
-                            on_change=lambda e: handle_geom_select(
-                                type_regex_mapping[e.value]
-                            ),
-                        ).props("inline")
-                stepper.set_value(geom_step)
-
-    ui.colors(primary="rgb(157 157 156)", secondary="rgb(57 92 127)")
-    ui.button.default_props("flat square no-caps")
-    ui.dropdown_button.default_props("flat square no-caps")
-    ui.select.default_props("square filled dense").default_classes("w-full")
-
-    app.storage.client["user_agent"] = request.headers.get("user-agent", None)
-
-    qgis = app.storage.client["user_agent"].startswith(get_settings().qgis_plugin_name)
-
-    feature_data = {}
-
-    if qgis:
-        ui.add_head_html('<script src="qrc:///qtwebchannel/qwebchannel.js"></script>')
-
-    try:
-        model = get_settings().repo.get(id)
-        # feature_type = model.get_name()
-        feature = model.model_dump(mode="json")
-    except ValueError:
-        ui.label("Feature nicht gefunden")
-        return
-    assocs = model.get_associations()
-    if not assocs:
-        ui.label("Feature verfügt über keine Assoziationen")
-        return
-    with ui.stepper().props("vertical flat").classes("w-full") as stepper:
-        with ui.step("Attribut auswählen"):
-            ui.label(
-                "Assoziationsattribut, für das ein neues Feature erzeugt werden soll, auswählen"
-            )
-            with ui.stepper_navigation():
-                prop_select = ui.select(
-                    assocs, on_change=handle_assoc_select, with_input=True
-                )
-        with ui.step("Featuretype auswählen"):
-            ui.label("Featuretype des neuen Features auswählen")
-            with ui.stepper_navigation():
-                type_select = ui.select(
-                    [], on_change=handle_type_select, with_input=True
-                )
-        # with ui.step("Bake"):
-        #     ui.label("Bake for 20 minutes")
-        #     with ui.stepper_navigation():
-        #         ui.button("Done", on_click=lambda: ui.notify("Yay!", type="positive"))
-        #         ui.button("Back", on_click=stepper.previous).props("flat")
-
-
 @app.get("/health_check")
-def health_check() -> str:
-    """
-    Health check endpoint to verify that the service is running.
+def health_check() -> dict:
+    """Health check endpoint to verify that the service is running.
 
     Returns:
-        str: A simple "OK" response indicating the application is healthy.
-    """
-    return "OK"
-
-
-# TODO replace with QWebChannel funcionality
-@app.post("/validate/{featuretype}")
-def validate_featuretype(
-    featuretype: str,
-    featureData: dict[str, Any],
-    appschema: str = get_settings().appschema,
-    version: str = get_settings().appschema_version,
-) -> str:
-    """
-    Validate feature data against the model.
-
-    Args:
-    featuretype (str): The type of the feature to validate (path parameter).
-    featureData (dict[str, Any]): Raw feature data to be validated.
-    appschema (str): Application schema name (default from settings).
-    version (str): Schema version string (default from settings).
+        dict: A simple dictionary with the app's name and version.
     """
-    # print(featureData)
-    featureData.pop("featuretype", None)
-    try:
-        model = model_factory(featuretype, version, appschema)
-        if (geom_field := model.get_geom_field()) and (
-            geom := featureData.pop("geometry", None)
-        ):
-            featureData[geom_field] = geom
-        model.model_validate(featureData)
-    except ValidationError as e:
-        raise HTTPException(
-            status_code=400,
-            detail={
-                "errors": e.errors(),
-            },
-        )
-    return "OK"
+    return {"name": "XMAS-App", "version": __version__}
 
 
 @app.post(
     "/insert-features", status_code=201, dependencies=[Depends(enforce_plugin_version)]
 )
-async def insert_features(payload: InsertPayload, planId: str):
+async def insert_features(payload: InsertPayload, planId: UUID):
     """Insert a number of features."""
-    await crud.create(payload, planId)
+    await crud.create(payload, str(planId))
 
 
 @app.post("/update-features", dependencies=[Depends(enforce_plugin_version)])

xmas_app/settings.py

@@ -63,7 +63,7 @@ class Settings(BaseSettings):
         "https://registry.gdi-de.org/codelist/de.xleitstelle.xplanung"
     )
     qgis_plugin_name: str = "XMAS-Plugin"
-    qgis_plugin_min_version: _VersionPydanticAnnotation = Version(major=0, minor=15)
+    qgis_plugin_min_version: _VersionPydanticAnnotation = Version(major=0, minor=16)
     mappings_toml: str = str(Path(__file__).parent / "resources/mappings.toml")
 
     model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")

{xmas_app-0.13.1.dist-info → xmas_app-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xmas-app
-Version: 0.13.1
+Version: 0.14.0
 Summary: The XLeitstelle model-driven application schema app.
 License: EUPL-1.2-or-later
 License-File: LICENSE
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Dist: nicegui (>=2.20,<3.0)
 Requires-Dist: pydantic-extra-types[semver]
 Requires-Dist: pydantic-settings (>=2.0,<3.0)
-Requires-Dist: xplan-tools (>=1.11.1,<1.12.0)
+Requires-Dist: xplan-tools (>=1.12.1,<1.13.0)
 Project-URL: Homepage, https://gitlab.opencode.de/xleitstelle/xmas-app
 Project-URL: Issues, https://gitlab.opencode.de/xleitstelle/xmas-app/-/issues
 Description-Content-Type: text/markdown

{xmas_app-0.13.1.dist-info → xmas_app-0.14.0.dist-info}/RECORD

@@ -2,11 +2,11 @@ xmas_app/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 xmas_app/components/association.py,sha256=xZUP-_S8IOmWEx_vWf5eipDjGWOSELdc_TEov8x-R9w,10270
 xmas_app/components/buttons.py,sha256=siwpqDFKcXxEMdaOglzgYeeuWKbiVLYW8BHi0Wx0HGk,2255
 xmas_app/components/label.py,sha256=WkqcHK4sGRFENiR_afrrkCDMGq_AZAT63zbN1GSpgv0,424
-xmas_app/db.py,sha256=bKzdCGW3yw-Nkf-wZAhXtrwDpRlLs0tJY5WhAA6xVoQ,12148
+xmas_app/db.py,sha256=J-D7FjobO3x8wvBfJdN9ZXfztLmaoN9ZopTNDflWZPk,7235
 xmas_app/db_uow.py,sha256=usvqo1bO4dQnMbiub5PyQAAgu8Af-HYAJTsFNYS3Le0,761
 xmas_app/deps/version_guard.py,sha256=ZcTtReXLsT-_dpQyELkajU2HbLvqIJgeU16pMHFAMyc,928
-xmas_app/form.py,sha256=hXqtEW_xuC0LdlpviuzVXjX-bg9SJQTLbLD1n9Xq_T8,58993
-xmas_app/main.py,sha256=9yOGyMPz85ohP6CYuN90MmHf5EU0ZuqMzPEd1e1x4OU,52327
+xmas_app/form.py,sha256=D1GQy77QBqmFUjHtSzEuUqwLvSxRq0kLWddx0jPXoRk,59039
+xmas_app/main.py,sha256=Eqfh3k2B5R45hMbVcTBYfsqgQeVyeGYxLxE4QUcvb4E,43121
 xmas_app/models/crud.py,sha256=Rtz-v2FpMM4AcTc_wcye_XjZtssTydgtSQcKuIK1yiM,418
 xmas_app/models/mappings.py,sha256=SwCbo_TQKiTDUy5-xkNEEIB3J7VFh-VsDbR2_0wyv0Q,213
 xmas_app/pygeoapi/config.yaml,sha256=lmb08zXk8-dB0sh_4EQ1enVBIqgBI-v6QcoIiHyH3N8,7992
@@ -15,12 +15,12 @@ xmas_app/pygeoapi/provider.py,sha256=uKHK_Hsqale1C2pNRKYpyka9GnNHYvGBmbzfcSi05NE
 xmas_app/resources/mappings.toml,sha256=VbDrooIdNmJOGLJtdg1Kh1bo_-DyUT7JL7aQMrBhRMU,97
 xmas_app/schema.py,sha256=3P-i14caMqydGsxNw6SOAcanEg1Qr4qxqciAow1aCUM,1507
 xmas_app/services/crud.py,sha256=lxH9kFIuOjaM1gEuWb9fbZ4a_hD2PI1_gjUwnfChD5g,4305
-xmas_app/settings.py,sha256=I4Q5JQRa0sEIBNX2Q8s3v_cr-bX0UiOjspCQ7_ThWCM,3419
+xmas_app/settings.py,sha256=Fb7KRnOSND1n9IhRwgnOt5txwOCpgaUSsFBlwNhrtgg,3419
 xmas_app/split_service.py,sha256=Ag_Ix2vMgT04OsQ0DIGK7WFKQlbktmmTqWlESO2ZgVs,26701
 xmas_app/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xmas_app/util/codelist.py,sha256=dUn7mOgTmV9Zi8A9iePyOyByMIe0Cf3ERn-n4eHrzM8,1961
-xmas_app-0.13.1.dist-info/METADATA,sha256=BcBSxfz_x6u-lnbXPIqPPJSCTURt8KxkJbyZ3l-HHFA,5323
-xmas_app-0.13.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-xmas_app-0.13.1.dist-info/entry_points.txt,sha256=uve2b0hgPbVfiD047-hOI6_dD97ZytvCPWk7HsN9Xng,53
-xmas_app-0.13.1.dist-info/licenses/LICENSE,sha256=b8nnCcy_4Nd_v_okJ6mDKCvi64jkexzbSfIag7TR5mU,13827
-xmas_app-0.13.1.dist-info/RECORD,,
+xmas_app-0.14.0.dist-info/METADATA,sha256=7kqqKNFmy5lhqdfyo85IvLd6h1SVJJVJ9QbtTAkVkVs,5323
+xmas_app-0.14.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+xmas_app-0.14.0.dist-info/entry_points.txt,sha256=uve2b0hgPbVfiD047-hOI6_dD97ZytvCPWk7HsN9Xng,53
+xmas_app-0.14.0.dist-info/licenses/LICENSE,sha256=b8nnCcy_4Nd_v_okJ6mDKCvi64jkexzbSfIag7TR5mU,13827
+xmas_app-0.14.0.dist-info/RECORD,,