dasf-exb-reference 0.1.0__tar.gz → 0.2.0__tar.gz

{dasf_exb_reference-0.1.0/dasf_exb_reference.egg-info → dasf_exb_reference-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dasf-exb-reference
-Version: 0.1.0
+Version: 0.2.0
 Summary: Reference implementation and Demonstration of a DASF Backend Module visualized by the dasf-experiencebuilder-plugin
 Author-email: "Philipp S. Sommer" <philipp.sommer@hereon.de>, Markus Benninghoff <markus.benninghoff@hereon.de>
 Maintainer-email: "Philipp S. Sommer" <philipp.sommer@hereon.de>, Markus Benninghoff <markus.benninghoff@hereon.de>
@@ -26,13 +26,17 @@ Description-Content-Type: text/markdown
 License-File: LICENSES/Apache-2.0.txt
 License-File: LICENSES/CC-BY-4.0.txt
 License-File: LICENSES/CC0-1.0.txt
-Requires-Dist: demessaging>=0.4.0
+Requires-Dist: dasf>=1.0.1
 Provides-Extra: backend
-Requires-Dist: demessaging[backend]; extra == "backend"
+Requires-Dist: dasf[backend]; extra == "backend"
 Requires-Dist: geodatasets; extra == "backend"
 Requires-Dist: geopandas; extra == "backend"
+Provides-Extra: openai
+Requires-Dist: dasf[openai]; extra == "openai"
+Provides-Extra: broker
+Requires-Dist: dasf[broker]; extra == "broker"
 Provides-Extra: testsite
-Requires-Dist: dasf-exb-reference[backend]; extra == "testsite"
+Requires-Dist: dasf-exb-reference[backend,broker,openai]; extra == "testsite"
 Requires-Dist: tox; extra == "testsite"
 Requires-Dist: isort==7.0.0; extra == "testsite"
 Requires-Dist: black==25.9.0; extra == "testsite"
@@ -40,7 +44,7 @@ Requires-Dist: blackdoc==0.4.6; extra == "testsite"
 Requires-Dist: flake8==7.3.0; extra == "testsite"
 Requires-Dist: pre-commit; extra == "testsite"
 Requires-Dist: mypy==1.18.2; extra == "testsite"
-Requires-Dist: dasf-broker-django>=0.0.1.dev0; extra == "testsite"
+Requires-Dist: dasf-broker-django[pytest]>=1.0.0; extra == "testsite"
 Requires-Dist: djangorestframework; extra == "testsite"
 Requires-Dist: pytest-django; extra == "testsite"
 Requires-Dist: pytest-cov; extra == "testsite"

{dasf_exb_reference-0.1.0 → dasf_exb_reference-0.2.0}/dasf_exb/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-05-12T14:50:48+0200",
+ "date": "2026-11-02T10:44:05+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "15b6443ca5d9dae4264837b9cf0fde3d00236c95",
- "version": "0.1.0"
+ "full-revisionid": "28b10ed9b9c275ca3d4b2a024ed41fa1d2ddd6ec",
+ "version": "0.2.0"
 }
 '''  # END VERSION_JSON
 

{dasf_exb_reference-0.1.0 → dasf_exb_reference-0.2.0}/dasf_exb/backend.py

@@ -11,14 +11,16 @@ This backend module provides some demo functions for demonstrating the
 
 import datetime as dt
 import os
-from typing import TYPE_CHECKING, Dict, List, Literal
+from typing import TYPE_CHECKING, Any, Dict, List, Literal
 
 import geodatasets
 import geopandas as gpd
 import pandas as pd
-from demessaging import configure, main, registry  # noqa: F401
+from dasf import configure, main, registry  # noqa: F401
+from dasf.reports import InputReport
 
 from .input_models import GeoArea, GeoLocation
+from .input_module import GeoAreaProperty, GeoLocationProperty
 from .return_models import (
     BinaryFile,
     DataSource,
@@ -37,6 +39,7 @@ __all__ = [
     "get_timeseries",
     "show_buttons",
     "get_multiple_responses",
+    "InputReporterDemo",
 ]
 
 
@@ -99,7 +102,7 @@ def get_geodataset(what: T_WHAT) -> GeoJson:
     """
     path = geodatasets.get_path(what)
     df = gpd.read_file(path)
-    return GeoJson(data=df.to_crs("EPSG: 4326").to_geo_dict(), title=what)
+    return GeoJson(data=df.to_crs("epsg:4326").to_geo_dict(), title=what)
 
 
 def get_point_info(
@@ -222,12 +225,38 @@ def get_multiple_responses() -> MultipleResponses:
     )
 
 
+class InputReporterDemo:
+    """Demo for asking the user for a location and an area on a map."""
+
+    def input_report_geo_demo(self) -> Dict[str, Any]:
+        """Ask the user for a location and an area on the map
+
+        Returns
+        -------
+        Dict[str, Any]
+            The response of the user, with the ``location`` (see
+            :class:`~dasf_exb.input_models.GeoLocation`) and the ``area`` (see
+            :class:`~dasf_exb.input_models.GeoArea`) that the user selected.
+        """
+        properties = {
+            "location": GeoLocationProperty(
+                description="Select a location on the map"
+            ),
+            "area": GeoAreaProperty(description="Select an area on the map"),
+        }
+        with InputReport() as reporter:
+            answer = reporter.ask_for_properties(
+                properties, "Select a location and an area"
+            )
+        return answer
+
+
 if __name__ == "__main__":
     if os.getenv("DE_MESSAGING_ENV_FILE"):
-        from demessaging.config import BaseMessagingConfig, ModuleConfig
+        from dasf.config import MessagingConfig, ModuleConfig
 
         config = ModuleConfig(
-            messaging_config=BaseMessagingConfig(  # type: ignore[arg-type]
+            messaging_config=MessagingConfig(  # type: ignore[arg-type]
                 topic="experience-builder-demo",
                 _env_file=os.environ["DE_MESSAGING_ENV_FILE"],
             )

{dasf_exb_reference-0.1.0 → dasf_exb_reference-0.2.0}/dasf_exb/download_geodatasets.py

@@ -21,7 +21,7 @@ def download_geodatasets():
     for key in geodatasets.data.flatten().keys():
         try:
             geodatasets.get_path(key)
-        except HTTPError as e:
+        except (ValueError, HTTPError) as e:
             print("Failed to download %s dataset: %s" % (key, e))
 
 

dasf_exb_reference-0.2.0/dasf_exb/input_module.py

@@ -0,0 +1,177 @@
+# SPDX-FileCopyrightText: 2026 Helmholtz-Zentrum hereon GmbH
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# This module is a backend module for the LLM tools of a chat, that extends
+# :mod:`dasf.utility_modules.input_module` with the
+# :class:`GeoLocationProperty` and the :class:`GeoAreaProperty`, to let the
+# user select a point or an area on a map. See there for how to use it. Pass
+# ``"dasf_exb.input_module"`` instead of
+# ``"dasf.utility_modules.input_module"`` to
+# :meth:`dasf.BackendModule.create_model`. The docstrings in this module are
+# the descriptions that the LLM gets for the tools.
+
+import inspect
+import textwrap
+import threading
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    Literal,
+    Mapping,
+    Optional,
+    Type,
+    Union,
+    cast,
+)
+
+from dasf import configure
+from dasf.reports.input import BaseProperty
+from dasf.utility_modules import input_module as dasf_input_module
+from pydantic import BaseModel, Field
+
+from .input_models import GeoArea, GeoLocation
+
+__doc__ = dasf_input_module.__doc__
+
+__all__ = ["ask_for_input"]
+
+
+def _model_schema(model: Type[BaseModel]) -> Dict[str, Any]:
+    """Get the JSON-Schema of `model` without any ``$ref``.
+
+    The schema of a property is embedded into the schema of the question, so
+    the ``$defs`` of the model would not be found at the root of the document.
+    """
+    schema = model.model_json_schema()
+    defs = schema.pop("$defs", {})
+
+    def resolve(node: Any) -> Any:
+        if isinstance(node, list):
+            return [resolve(item) for item in node]
+        if not isinstance(node, dict):
+            return node
+        resolved = {
+            key: resolve(value) for key, value in node.items() if key != "$ref"
+        }
+        if "$ref" in node:
+            resolved = {
+                **resolve(defs[node["$ref"].rsplit("/", 1)[-1]]),
+                **resolved,
+            }
+        return resolved
+
+    return resolve(schema)
+
+
+class _GeoProperty(BaseProperty):
+    """Base class for the properties that the user selects on a map.
+
+    The :attr:`~BaseProperty.type` of these properties is not a JSON-Schema
+    type, but tells them apart from each other. The user cannot choose from a
+    list of values here, but selects the value on a map.
+    """
+
+    #: The model that the answer of the user must match
+    _geo_model: ClassVar[Type[BaseModel]]
+
+    choices: Literal[None] = Field(  # type: ignore
+        None, description="This is disabled for properties on a map."
+    )
+
+    accepts_other: Literal[False] = Field(  # type: ignore
+        False, description="This is disabled for properties on a map."
+    )
+
+    def to_json_schema(self) -> Dict[str, Any]:
+        """Get the JSON-Schema of this property.
+
+        This is the schema of the model that the property is selected for. It
+        has the ``uiSchema`` of this model, that makes the frontend show a
+        map to the user.
+        """
+        schema = _model_schema(self._geo_model)
+        if self.description:
+            schema["description"] = self.description
+        if self.default is not None:
+            schema["default"] = cast(BaseModel, self.default).model_dump()
+        return schema
+
+
+class GeoLocationProperty(_GeoProperty):
+    """A location on a map that the user is asked for.
+
+    The answer is an object with the longitude (``lon``) and the latitude
+    (``lat``) of the point that the user selected.
+    """
+
+    _geo_model: ClassVar[Type[BaseModel]] = GeoLocation
+
+    type: Literal["geolocation"] = Field(  # type: ignore
+        "geolocation", description="The type of the property."
+    )
+
+    default: Optional[GeoLocation] = None
+
+
+class GeoAreaProperty(_GeoProperty):
+    """An area on a map that the user is asked for.
+
+    The answer is an object with the ``points`` (each of them with a
+    longitude ``lon`` and a latitude ``lat``) of the polygon that the user
+    selected.
+    """
+
+    _geo_model: ClassVar[Type[BaseModel]] = GeoArea
+
+    type: Literal["geoarea"] = Field(  # type: ignore
+        "geoarea", description="The type of the property."
+    )
+
+    default: Optional[GeoArea] = None
+
+
+#: The properties that the user can be asked for
+Property = Union[
+    dasf_input_module.Property, GeoLocationProperty, GeoAreaProperty
+]
+
+
+@configure(cancelable=True)
+def ask_for_input(
+    cancel_event: Optional[threading.Event],
+    prompt: str,
+    properties: Mapping[str, Property],
+) -> Dict[str, Any]:
+    # the docstring is set below
+    return dasf_input_module.ask_for_input(
+        cancel_event, prompt, properties  # type: ignore[arg-type]
+    )
+
+
+# The docstring is what the LLM gets as the description of the tool. It is the
+# one of the dasf function, extended by the description of the geo properties
+# at the end of the description of the `properties`, i.e. before the section
+# with the return value.
+_head, _sep, _tail = inspect.cleandoc(
+    dasf_input_module.ask_for_input.__doc__ or ""
+).partition("\nReturns\n")
+ask_for_input.__doc__ = (
+    _head.rstrip()
+    + "\n"
+    + textwrap.indent(
+        textwrap.fill(
+            "In addition to these types, the ``type`` of a property can be "
+            '``"geolocation"`` or ``"geoarea"``. The user then selects a '
+            "point or an area on a map. The answer is an object with ``lon`` "
+            "and ``lat`` for the point, and an object with a list of such "
+            "``points`` for the area. These have neither ``choices`` nor "
+            "``accepts_other``.",
+            width=75,
+        ),
+        "    ",
+    )
+    + _sep
+    + _tail
+)

{dasf_exb_reference-0.1.0 → dasf_exb_reference-0.2.0}/dasf_exb/return_models.py

@@ -135,9 +135,9 @@ class DataSource(BaseModel):
 
     response_type: Literal["datasource"] = "datasource"
 
-    records: List[Dict[str, Union[str, dt.datetime, dt.date, float, int]]] = (
-        Field(description="The individual record information.")
-    )
+    records: List[
+        Dict[str, Union[None, str, dt.datetime, dt.date, float, int]]
+    ] = Field(description="The individual record information.")
 
     name: str = Field(
         description="Name of the datasource in the frontend application",

{dasf_exb_reference-0.1.0 → dasf_exb_reference-0.2.0/dasf_exb_reference.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dasf-exb-reference
-Version: 0.1.0
+Version: 0.2.0
 Summary: Reference implementation and Demonstration of a DASF Backend Module visualized by the dasf-experiencebuilder-plugin
 Author-email: "Philipp S. Sommer" <philipp.sommer@hereon.de>, Markus Benninghoff <markus.benninghoff@hereon.de>
 Maintainer-email: "Philipp S. Sommer" <philipp.sommer@hereon.de>, Markus Benninghoff <markus.benninghoff@hereon.de>
@@ -26,13 +26,17 @@ Description-Content-Type: text/markdown
 License-File: LICENSES/Apache-2.0.txt
 License-File: LICENSES/CC-BY-4.0.txt
 License-File: LICENSES/CC0-1.0.txt
-Requires-Dist: demessaging>=0.4.0
+Requires-Dist: dasf>=1.0.1
 Provides-Extra: backend
-Requires-Dist: demessaging[backend]; extra == "backend"
+Requires-Dist: dasf[backend]; extra == "backend"
 Requires-Dist: geodatasets; extra == "backend"
 Requires-Dist: geopandas; extra == "backend"
+Provides-Extra: openai
+Requires-Dist: dasf[openai]; extra == "openai"
+Provides-Extra: broker
+Requires-Dist: dasf[broker]; extra == "broker"
 Provides-Extra: testsite
-Requires-Dist: dasf-exb-reference[backend]; extra == "testsite"
+Requires-Dist: dasf-exb-reference[backend,broker,openai]; extra == "testsite"
 Requires-Dist: tox; extra == "testsite"
 Requires-Dist: isort==7.0.0; extra == "testsite"
 Requires-Dist: black==25.9.0; extra == "testsite"
@@ -40,7 +44,7 @@ Requires-Dist: blackdoc==0.4.6; extra == "testsite"
 Requires-Dist: flake8==7.3.0; extra == "testsite"
 Requires-Dist: pre-commit; extra == "testsite"
 Requires-Dist: mypy==1.18.2; extra == "testsite"
-Requires-Dist: dasf-broker-django>=0.0.1.dev0; extra == "testsite"
+Requires-Dist: dasf-broker-django[pytest]>=1.0.0; extra == "testsite"
 Requires-Dist: djangorestframework; extra == "testsite"
 Requires-Dist: pytest-django; extra == "testsite"
 Requires-Dist: pytest-cov; extra == "testsite"

{dasf_exb_reference-0.1.0 → dasf_exb_reference-0.2.0}/dasf_exb_reference.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ dasf_exb/_version.py
 dasf_exb/backend.py
 dasf_exb/download_geodatasets.py
 dasf_exb/input_models.py
+dasf_exb/input_module.py
 dasf_exb/py.typed
 dasf_exb/return_models.py
 dasf_exb_reference.egg-info/PKG-INFO
@@ -19,4 +20,6 @@ dasf_exb_reference.egg-info/not-zip-safe
 dasf_exb_reference.egg-info/requires.txt
 dasf_exb_reference.egg-info/top_level.txt
 tests/test_backend.py
-tests/test_imports.py
+tests/test_connected_module.py
+tests/test_imports.py
+tests/test_input_module.py

{dasf_exb_reference-0.1.0 → dasf_exb_reference-0.2.0}/dasf_exb_reference.egg-info/requires.txt

@@ -1,10 +1,13 @@
-demessaging>=0.4.0
+dasf>=1.0.1
 
 [backend]
-demessaging[backend]
+dasf[backend]
 geodatasets
 geopandas
 
+[broker]
+dasf[broker]
+
 [dev]
 dasf-exb-reference[testsite]
 dasf-exb-reference[docs]
@@ -18,8 +21,11 @@ hereon-netcdf-sphinxext
 sphinx-design
 myst_parser
 
+[openai]
+dasf[openai]
+
 [testsite]
-dasf-exb-reference[backend]
+dasf-exb-reference[backend,broker,openai]
 tox
 isort==7.0.0
 black==25.9.0
@@ -27,7 +33,7 @@ blackdoc==0.4.6
 flake8==7.3.0
 pre-commit
 mypy==1.18.2
-dasf-broker-django>=0.0.1.dev0
+dasf-broker-django[pytest]>=1.0.0
 djangorestframework
 pytest-django
 pytest-cov

{dasf_exb_reference-0.1.0 → dasf_exb_reference-0.2.0}/pyproject.toml

@@ -47,7 +47,7 @@ classifiers = [
 
 requires-python = '>= 3.9'
 dependencies = [
-    "demessaging>=0.4.0",
+    "dasf>=1.0.1",
     # add your dependencies here
 ]
 
@@ -60,12 +60,21 @@ Tracker = "https://codebase.helmholtz.cloud/dasf/demos/dasf-exb-reference/issues
 
 [project.optional-dependencies]
 backend = [
-    "demessaging[backend]",
+    "dasf[backend]",
     "geodatasets",
     "geopandas",
 ]
+
+openai = [
+    "dasf[openai]",
+]
+# everything that the development message broker (the runserver command of the
+# backend module) needs
+broker = [
+    "dasf[broker]",
+]
 testsite = [
-    "dasf-exb-reference[backend]",
+    "dasf-exb-reference[backend, broker, openai]",
     "tox",
     "isort==7.0.0",
     "black==25.9.0",
@@ -73,7 +82,7 @@ testsite = [
     "flake8==7.3.0",
     "pre-commit",
     "mypy==1.18.2",
-    "dasf-broker-django>=0.0.1.dev0",
+    "dasf-broker-django[pytest]>=1.0.0",
     "djangorestframework",
     "pytest-django",
     "pytest-cov",
@@ -119,7 +128,7 @@ exclude = [
 
 [tool.pytest.ini_options]
 addopts = '-v'
-DJANGO_SETTINGS_MODULE = "testproject.settings"
+DJANGO_SETTINGS_MODULE = "dasf.dev_broker.settings"
 
 [tool.versioneer]
 VCS = 'git'

dasf_exb_reference-0.2.0/tests/test_backend.py

@@ -0,0 +1,123 @@
+# SPDX-FileCopyrightText: 2025 Helmholtz-Zentrum hereon GmbH
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Test module for :mod:`dasf_exb.backend`."""
+
+import json
+
+
+def test_show_version():
+    from dasf_exb import __version__ as ref_version
+    from dasf_exb import backend
+
+    version_info = backend.version_info()
+    assert "dasf-exb-reference" in version_info
+    assert version_info["dasf-exb-reference"] == ref_version
+
+
+def test_get_geodataset():
+    from dasf_exb import backend
+
+    geojson = backend.get_geodataset("naturalearth.land")
+    assert geojson is not None
+
+
+def test_get_point_info():
+    from dasf_exb import backend
+    from dasf_exb.input_models import GeoLocation
+
+    text = backend.get_point_info(
+        GeoLocation(lat=40, lon=40), [GeoLocation(lat=30, lon=30)]
+    )
+    assert "lon: 40" in text
+    assert "lat: 40" in text
+    assert "lon: 30" in text
+    assert "lat: 30" in text
+
+
+def test_get_timeseries():
+    import pandas as pd
+
+    from dasf_exb import backend
+
+    timeseries = backend.get_timeseries()
+
+    df = pd.DataFrame.from_dict(timeseries.records)
+    assert sorted(df.columns) == ["date", "value", "value2"]
+    assert len(df) == 10
+
+
+def test_get_multiple_responses():
+    import pandas as pd
+
+    from dasf_exb import backend
+
+    responses = backend.get_multiple_responses()
+
+    df = pd.DataFrame.from_dict(responses.data[0].records)
+    assert sorted(df.columns) == ["date", "value", "value2"]
+    assert len(df) == 10
+
+
+def test_create_backend_module():
+    """Test that dasf accepts the module.
+
+    dasf creates the model for the requests when the backend module is
+    created. It rejects, for instance, functions with a report as parameter.
+    """
+    from dasf import BackendModule
+
+    Model = BackendModule.create_model(
+        "dasf_exb.backend", messaging_config=dict(topic="test")
+    )
+
+    schema = json.dumps(Model.model_json_schema())
+    assert "get_point_info" in schema
+    assert "InputReporterDemo" in schema
+
+
+def test_process_point_request():
+    """Test a request for a function with the models of this package."""
+    from dasf import BackendModule
+
+    Model = BackendModule.create_model(
+        "dasf_exb.backend", messaging_config=dict(topic="test")
+    )
+
+    result = Model.process_request(
+        {
+            "func_name": "get_point_info",
+            "point": {"lon": 40, "lat": 41},
+            "points": [{"lon": 30, "lat": 31}],
+        }
+    )
+
+    assert "lon: 40" in result.root
+    assert "lat: 41" in result.root
+    assert "lon: 30" in result.root
+
+
+def test_input_report_geo_demo(asked_questions):
+    """Test that the demo asks for a location and an area on the map."""
+    from dasf import BackendModule
+
+    from dasf_exb.input_module import GeoAreaProperty, GeoLocationProperty
+
+    Model = BackendModule.create_model(
+        "dasf_exb.backend", messaging_config=dict(topic="test")
+    )
+
+    result = Model.process_request(
+        {
+            "class_name": "InputReporterDemo",
+            "function": {"func_name": "input_report_geo_demo"},
+        }
+    )
+
+    assert result.root == {"location": "location", "area": "area"}
+    assert len(asked_questions) == 1
+    properties, prompt = asked_questions[0]
+    assert prompt == "Select a location and an area"
+    assert isinstance(properties["location"], GeoLocationProperty)
+    assert isinstance(properties["area"], GeoAreaProperty)

dasf_exb_reference-0.2.0/tests/test_connected_module.py

@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: 2026 Helmholtz-Zentrum hereon GmbH
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for the backend module that is connected to a message broker."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Callable, Dict, Union
+
+if TYPE_CHECKING:
+    import subprocess as spr
+
+
+def test_request_via_broker(
+    connected_module: spr.Popen,
+    random_topic: str,
+    test_dasf_request: Callable[[str, str, Union[Dict, str]], str],
+):
+    """Send a request to the module via a message broker.
+
+    The module runs in a process of its own, that is connected to a live
+    development broker (see the ``connected_module`` fixture).
+    """
+    assert connected_module.poll() is None
+
+    output = test_dasf_request(
+        random_topic,
+        "dasf_exb.backend",
+        {
+            "func_name": "get_point_info",
+            "point": {"lon": 40, "lat": 41},
+            "points": [{"lon": 30, "lat": 31}],
+        },
+    )
+
+    text = json.loads(output)
+    assert "lon: 40" in text
+    assert "lat: 41" in text
+    assert "lon: 30" in text

dasf_exb_reference-0.2.0/tests/test_input_module.py

@@ -0,0 +1,226 @@
+# SPDX-FileCopyrightText: 2026 Helmholtz-Zentrum hereon GmbH
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Test module for :mod:`dasf_exb.input_module`."""
+
+import json
+import threading
+from typing import Any, Dict, Type
+
+import docstring_parser
+import jsonschema
+import pytest
+from dasf import BackendModule
+from dasf.reports.input import (
+    BaseProperty,
+    BooleanProperty,
+    FloatProperty,
+    IntegerProperty,
+    StringProperty,
+    properties_to_schema,
+)
+from pydantic import TypeAdapter, ValidationError
+
+from dasf_exb import input_module
+from dasf_exb.input_models import GeoLocation
+from dasf_exb.input_module import (
+    GeoAreaProperty,
+    GeoLocationProperty,
+    Property,
+    ask_for_input,
+)
+
+TOPIC = "user_input"
+
+
+@pytest.fixture
+def module() -> Type[BackendModule]:
+    return BackendModule.create_model(
+        "dasf_exb.input_module", messaging_config=dict(topic=TOPIC)
+    )
+
+
+def test_single_function():
+    assert input_module.__all__ == ["ask_for_input"]
+    assert callable(ask_for_input)
+
+
+class TestGeoProperties:
+    def test_location_schema(self):
+        schema = GeoLocationProperty(description="Pick").to_json_schema()
+
+        # the schema is embedded into the one of the question, so there must
+        # not be a reference to the definitions
+        assert "$ref" not in json.dumps(schema)
+        assert "$defs" not in schema
+        assert schema["description"] == "Pick"
+        assert schema["uiSchema"]["ui:field"] == "GeoLocation"
+        assert sorted(schema["properties"]) == ["lat", "lon"]
+        assert sorted(schema["required"]) == ["lat", "lon"]
+
+    def test_location_default(self):
+        prop = GeoLocationProperty(default=GeoLocation(lon=10, lat=20))
+        assert prop.to_json_schema()["default"] == {"lon": 10.0, "lat": 20.0}
+
+    def test_area_schema(self):
+        schema = GeoAreaProperty(description="Pick an area").to_json_schema()
+
+        assert "$ref" not in json.dumps(schema)
+        assert schema["description"] == "Pick an area"
+        assert schema["uiSchema"]["ui:field"] == "GeoArea"
+        # the points are resolved, too
+        points = schema["properties"]["points"]["items"]
+        assert sorted(points["properties"]) == ["lat", "lon"]
+
+    @pytest.mark.parametrize(
+        "kws", [{"choices": ["a"]}, {"accepts_other": True}]
+    )
+    @pytest.mark.parametrize("cls", [GeoLocationProperty, GeoAreaProperty])
+    def test_no_choices(self, cls: Type[GeoLocationProperty], kws):
+        """The user selects on a map, there is nothing to choose from."""
+        with pytest.raises(ValidationError):
+            cls(**kws)
+
+    def test_answers_are_validated(self):
+        """The answers are validated by dasf against the schema we created."""
+        properties = {
+            "name": StringProperty(description="Your name"),
+            "location": GeoLocationProperty(description="Pick"),
+            "area": GeoAreaProperty(description="Pick an area"),
+        }
+        schema = properties_to_schema(properties)
+        point = {"lon": 10, "lat": 20}
+
+        jsonschema.validate(
+            {"name": "Peter", "location": point, "area": {"points": [point]}},
+            schema,
+        )
+
+        with pytest.raises(jsonschema.ValidationError):
+            jsonschema.validate(
+                {
+                    "name": "Peter",
+                    "location": {"lon": 10, "lat": 91},  # not a latitude
+                    "area": {"points": [point]},
+                },
+                schema,
+            )
+
+
+class TestProperty:
+    @pytest.mark.parametrize(
+        "type_, cls",
+        [
+            ("integer", IntegerProperty),
+            ("number", FloatProperty),
+            ("string", StringProperty),
+            ("boolean", BooleanProperty),
+            ("geolocation", GeoLocationProperty),
+            ("geoarea", GeoAreaProperty),
+        ],
+    )
+    def test_union(self, type_: str, cls: type):
+        """The ``type`` of a property tells which one it is."""
+        prop: BaseProperty = TypeAdapter(Property).validate_python(
+            {"type": type_, "description": "something"}
+        )
+        assert type(prop) is cls
+
+    def test_unknown_type(self):
+        with pytest.raises(ValidationError):
+            TypeAdapter(Property).validate_python({"type": "other"})
+
+
+class TestAskForInput:
+    def test_docstring(self):
+        """The LLM gets the description of the geo properties."""
+        doc = docstring_parser.parse(ask_for_input.__doc__ or "")
+
+        params = {param.arg_name: param for param in doc.params}
+        assert sorted(params) == ["prompt", "properties"]
+        description = params["properties"].description or ""
+        # the description of dasf is still there ...
+        assert "accepts_other" in description
+        # ... and we added ours
+        assert '"geolocation"' in description
+        assert '"geoarea"' in description
+        # and it ends up in the description of the parameter, not of the
+        # return value
+        assert doc.returns is not None
+        assert "geo" not in (doc.returns.description or "")
+
+    def test_schema(self, module: Type[BackendModule]):
+        """The LLM can choose the geo properties and has no reporter."""
+        defs: Dict[str, Any] = module.model_json_schema()["$defs"]
+
+        assert "GeoLocationProperty" in defs
+        assert "GeoAreaProperty" in defs
+        (func,) = [
+            func
+            for func in defs.values()
+            if func.get("properties", {}).get("func_name", {}).get("const")
+            == "ask_for_input"
+        ]
+        assert sorted(func["properties"]) == [
+            "func_name",
+            "prompt",
+            "properties",
+        ]
+        variants = func["properties"]["properties"]["additionalProperties"][
+            "anyOf"
+        ]
+        assert {"$ref": "#/$defs/GeoLocationProperty"} in variants
+        assert {"$ref": "#/$defs/GeoAreaProperty"} in variants
+
+    def test_request(self, module: Type[BackendModule], asked_questions):
+        """Test the request of the LLM with properties on a map."""
+        result = module.process_request(
+            {
+                "func_name": "ask_for_input",
+                "prompt": "Where are you?",
+                "properties": {
+                    "name": {"type": "string", "description": "Your name"},
+                    "location": {
+                        "type": "geolocation",
+                        "description": "Your location",
+                    },
+                    "area": {"type": "geoarea", "description": "Your area"},
+                },
+            }
+        )
+
+        assert result.root == {
+            "name": "name",
+            "location": "location",
+            "area": "area",
+        }
+        assert len(asked_questions) == 1
+        properties, prompt = asked_questions[0]
+        assert prompt == "Where are you?"
+        assert isinstance(properties["name"], StringProperty)
+        assert isinstance(properties["location"], GeoLocationProperty)
+        assert properties["location"].description == "Your location"
+        assert isinstance(properties["area"], GeoAreaProperty)
+
+    def test_cancel(self, monkeypatch: pytest.MonkeyPatch, asked_questions):
+        """The event to cancel the question gets to the question."""
+        from dasf.reports import InputReport
+
+        stop_events = []
+        ask_for_properties = InputReport.ask_for_properties
+
+        def spy(self, properties, prompt=None, stop_event=None, *args):
+            stop_events.append(stop_event)
+            return ask_for_properties(self, properties, prompt, stop_event)
+
+        monkeypatch.setattr(InputReport, "ask_for_properties", spy)
+        cancel_event = threading.Event()
+
+        ask_for_input(
+            cancel_event,
+            "Where are you?",
+            {"location": GeoLocationProperty(description="Your location")},
+        )
+
+        assert stop_events == [cancel_event]

dasf_exb_reference-0.1.0/tests/test_backend.py

@@ -1,58 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Helmholtz-Zentrum hereon GmbH
-#
-# SPDX-License-Identifier: Apache-2.0
-
-"""Test module for :mod:`dasf_exb.backend`."""
-
-
-def test_show_version():
-    from dasf_exb import __version__ as ref_version
-    from dasf_exb import backend
-
-    version_info = backend.version_info()
-    assert "dasf-exb-reference" in version_info
-    assert version_info["dasf-exb-reference"] == ref_version
-
-
-def test_get_geodataset():
-    from dasf_exb import backend
-
-    geojson = backend.get_geodataset("naturalearth.land")
-    assert geojson is not None
-
-
-def test_get_point_info():
-    from dasf_exb import backend
-    from dasf_exb.input_models import GeoLocation
-
-    text = backend.get_point_info(
-        GeoLocation(lat=40, lon=40), [GeoLocation(lat=30, lon=30)]
-    )
-    assert "lon: 40" in text
-    assert "lat: 40" in text
-    assert "lon: 30" in text
-    assert "lat: 30" in text
-
-
-def test_get_timeseries():
-    import pandas as pd
-
-    from dasf_exb import backend
-
-    timeseries = backend.get_timeseries()
-
-    df = pd.DataFrame.from_dict(timeseries.records)
-    assert sorted(df.columns) == ["date", "value", "value2"]
-    assert len(df) == 10
-
-
-def test_get_multiple_responses():
-    import pandas as pd
-
-    from dasf_exb import backend
-
-    responses = backend.get_multiple_responses()
-
-    df = pd.DataFrame.from_dict(responses.data[0].records)
-    assert sorted(df.columns) == ["date", "value", "value2"]
-    assert len(df) == 10