dsp-tools 17.0.0.post14__py3-none-any.whl → 17.0.0.post23__py3-none-any.whl

dsp_tools/clients/metadata_client.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+from enum import Enum
+from enum import auto
+from typing import Protocol
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+
+
+class MetadataRetrieval(Enum):
+    SUCCESS = auto()
+    FAILURE = auto()
+
+
+@dataclass
+class MetadataClient(Protocol):
+    """
+    Protocol class/interface for the metadata endpoint in the API.
+    """
+
+    server: str
+    authentication_client: AuthenticationClient
+
+    def get_resource_metadata(self, shortcode: str) -> tuple[MetadataRetrieval, list[dict[str, str]]]:
+        """Get all resource metadata from one project."""

dsp_tools/clients/metadata_client_live.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+
+import requests
+from loguru import logger
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.metadata_client import MetadataClient
+from dsp_tools.clients.metadata_client import MetadataRetrieval
+from dsp_tools.utils.request_utils import RequestParameters
+from dsp_tools.utils.request_utils import log_request
+from dsp_tools.utils.request_utils import log_response
+
+TIMEOUT = 120
+
+
+@dataclass
+class MetadataClientLive(MetadataClient):
+    server: str
+    authentication_client: AuthenticationClient
+
+    def get_resource_metadata(self, shortcode: str) -> tuple[MetadataRetrieval, list[dict[str, str]]]:
+        url = f"{self.server}/v2/metadata/projects/{shortcode}/resources?format=JSON"
+        header = {"Authorization": f"Bearer {self.authentication_client.get_token()}"}
+        params = RequestParameters(method="GET", url=url, timeout=TIMEOUT, headers=header)
+        logger.debug("GET Resource Metadata")
+        log_request(params)
+        try:
+            response = requests.get(
+                url=params.url,
+                headers=params.headers,
+                timeout=params.timeout,
+            )
+            if response.ok:
+                # we log the response separately because if it was successful it will be too big
+                log_response(response, include_response_content=False)
+                return MetadataRetrieval.SUCCESS, response.json()
+            # here the response text is important
+            log_response(response)
+            return MetadataRetrieval.FAILURE, []
+        except Exception as err:  # noqa: BLE001 (blind exception)
+            logger.error(err)
+            return MetadataRetrieval.FAILURE, []

dsp_tools/clients/ontology_client.py

@@ -0,0 +1,21 @@
+from typing import Any
+from typing import Protocol
+
+from rdflib import Literal
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+
+
+class OntologyClient(Protocol):
+    """
+    Protocol class/interface for the ontology endpoint in the API.
+    """
+
+    server: str
+    authentication_client: AuthenticationClient
+
+    def get_last_modification_date(self, project_iri: str, onto_iri: str) -> str:
+        """Get the last modification date of an ontology"""
+
+    def post_resource_cardinalities(self, cardinality_graph: dict[str, Any]) -> Literal | None:
+        """Add cardinalities to an existing resource class."""

dsp_tools/clients/ontology_client_live.py

@@ -0,0 +1,139 @@
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import Any
+
+import requests
+from loguru import logger
+from rdflib import Graph
+from rdflib import Literal
+from rdflib import URIRef
+from requests import ReadTimeout
+from requests import Response
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.ontology_client import OntologyClient
+from dsp_tools.error.exceptions import BadCredentialsError
+from dsp_tools.error.exceptions import UnexpectedApiResponseError
+from dsp_tools.utils.rdflib_constants import KNORA_API
+from dsp_tools.utils.request_utils import RequestParameters
+from dsp_tools.utils.request_utils import log_and_raise_timeouts
+from dsp_tools.utils.request_utils import log_request
+from dsp_tools.utils.request_utils import log_response
+
+TIMEOUT = 60
+
+
+@dataclass
+class OntologyClientLive(OntologyClient):
+    """
+    Client for the ontology endpoint in the API.
+    """
+
+    server: str
+    authentication_client: AuthenticationClient
+
+    def get_last_modification_date(self, project_iri: str, onto_iri: str) -> Literal:
+        url = f"{self.server}/v2/ontologies/metadata"
+        header = {"X-Knora-Accept-Project": project_iri}
+        logger.debug("GET ontology metadata")
+        try:
+            response = self._get_and_log_request(url, header)
+        except (TimeoutError, ReadTimeout) as err:
+            log_and_raise_timeouts(err)
+        if response.ok:
+            date = _parse_last_modification_date(response.text, URIRef(onto_iri))
+            if not date:
+                raise UnexpectedApiResponseError(
+                    f"Could not find the last modification date of the ontology '{onto_iri}' "
+                    f"in the response: {response.text}"
+                )
+            return date
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError("You do not have sufficient credentials to retrieve ontology metadata.")
+        else:
+            raise UnexpectedApiResponseError(
+                f"An unexpected response with the status code {response.status_code} was received from the API. "
+                f"Please consult 'warnings.log' for details."
+            )
+
+    def post_resource_cardinalities(self, cardinality_graph: dict[str, Any]) -> Literal | None:
+        url = f"{self.server}/v2/ontologies/cardinalities"
+
+        logger.debug("POST resource cardinalities to ontology")
+        try:
+            response = self._post_and_log_request(url, cardinality_graph)
+        except (TimeoutError, ReadTimeout) as err:
+            log_and_raise_timeouts(err)
+        if response.ok:
+            date = _parse_last_modification_date(response.text)
+            if not date:
+                raise UnexpectedApiResponseError(
+                    f"Could not find the last modification date in the response: {response.text}"
+                )
+            return date
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError(
+                "Only a project or system administrator can add cardinalities to resource classes. "
+                "Your permissions are insufficient for this action."
+            )
+        else:
+            logger.error(
+                f"During cardinality creation an unexpected response with the status code {response.status_code} "
+                f"was received from the API."
+            )
+            return None
+
+    def _post_and_log_request(
+        self,
+        url: str,
+        data: dict[str, Any] | None,
+        headers: dict[str, str] | None = None,
+    ) -> Response:
+        data_dict, generic_headers = self._prepare_request(data, headers)
+        params = RequestParameters("POST", url, TIMEOUT, data_dict, generic_headers)
+        log_request(params)
+        response = requests.post(
+            url=params.url,
+            headers=params.headers,
+            data=params.data_serialized,
+            timeout=params.timeout,
+        )
+        log_response(response)
+        return response
+
+    def _get_and_log_request(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+    ) -> Response:
+        _, generic_headers = self._prepare_request({}, headers)
+        params = RequestParameters(method="GET", url=url, timeout=TIMEOUT, headers=generic_headers)
+        log_request(params)
+        response = requests.get(
+            url=params.url,
+            headers=params.headers,
+            timeout=params.timeout,
+        )
+        log_response(response)
+        return response
+
+    def _prepare_request(
+        self, data: dict[str, Any] | None, headers: dict[str, str] | None
+    ) -> tuple[dict[str, Any] | None, dict[str, str]]:
+        generic_headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.authentication_client.get_token()}",
+        }
+        data_dict = data if data else None
+        if headers:
+            generic_headers.update(headers)
+        return data_dict, generic_headers
+
+
+def _parse_last_modification_date(response_text: str, onto_iri: URIRef | None = None) -> Literal | None:
+    g = Graph()
+    g.parse(data=response_text, format="json-ld")
+    result = next(g.objects(subject=onto_iri, predicate=KNORA_API.lastModificationDate), None)
+    if isinstance(result, Literal):
+        return result
+    return None

dsp_tools/commands/create/communicate_problems.py

@@ -0,0 +1,19 @@
+from loguru import logger
+
+from dsp_tools.commands.create.models.input_problems import CollectedProblems
+from dsp_tools.commands.create.models.input_problems import CreateProblem
+from dsp_tools.utils.ansi_colors import BOLD_RED
+from dsp_tools.utils.ansi_colors import RED
+from dsp_tools.utils.ansi_colors import RESET_TO_DEFAULT
+
+
+def print_problem_collection(problem_collection: CollectedProblems) -> None:
+    individual_problems = _create_individual_problem_strings(problem_collection.problems)
+    logger.error(problem_collection.header, individual_problems)
+    print(BOLD_RED, problem_collection.header, RESET_TO_DEFAULT)
+    print(RED, individual_problems, RESET_TO_DEFAULT)
+
+
+def _create_individual_problem_strings(problems: list[CreateProblem]) -> str:
+    str_list = [f"{p.problematic_object}: {p.problem!s}" for p in problems]
+    return "   - " + "\n    - ".join(str_list)

dsp_tools/commands/create/constants.py

@@ -1,4 +1,7 @@
-KNORA_API = "http://api.knora.org/ontology/knora-api/v2#"
-SALSAH_GUI = "http://api.knora.org/ontology/salsah-gui/v2#"
+from rdflib import Namespace
 
-UNIVERSAL_PREFIXES = {"knora-api": KNORA_API, "salsah-gui": SALSAH_GUI}
+KNORA_API_STR = "http://api.knora.org/ontology/knora-api/v2#"
+SALSAH_GUI_STR = "http://api.knora.org/ontology/salsah-gui/v2#"
+SALSAH_GUI = Namespace(SALSAH_GUI_STR)
+
+UNIVERSAL_PREFIXES = {"knora-api": KNORA_API_STR, "salsah-gui": SALSAH_GUI_STR}

dsp_tools/commands/create/create_on_server/cardinalities.py

@@ -0,0 +1,121 @@
+from typing import Any
+
+from loguru import logger
+from rdflib import Literal
+from rdflib import URIRef
+
+from dsp_tools.clients.ontology_client import OntologyClient
+from dsp_tools.clients.ontology_client_live import OntologyClientLive
+from dsp_tools.commands.create.models.input_problems import CollectedProblems
+from dsp_tools.commands.create.models.input_problems import CreateProblem
+from dsp_tools.commands.create.models.input_problems import ProblemType
+from dsp_tools.commands.create.models.input_problems import UploadProblem
+from dsp_tools.commands.create.models.parsed_ontology import ParsedClassCardinalities
+from dsp_tools.commands.create.models.parsed_ontology import ParsedOntology
+from dsp_tools.commands.create.models.parsed_ontology import ParsedPropertyCardinality
+from dsp_tools.commands.create.models.server_project_info import CreatedIriCollection
+from dsp_tools.commands.create.models.server_project_info import ProjectIriLookup
+from dsp_tools.commands.create.serialisation.ontology import _make_one_cardinality_graph
+from dsp_tools.commands.create.serialisation.ontology import make_ontology_base_graph
+from dsp_tools.utils.data_formats.iri_util import from_dsp_iri_to_prefixed_iri
+from dsp_tools.utils.rdflib_utils import serialise_json
+
+
+def add_all_cardinalities(
+    ontologies: list[ParsedOntology],
+    project_iri_lookup: ProjectIriLookup,
+    created_iris: CreatedIriCollection,
+    onto_client: OntologyClientLive,
+) -> CollectedProblems | None:
+    all_problems = []
+    for onto in ontologies:
+        onto_iri = project_iri_lookup.onto_iris.get(onto.name)
+        # we do not inform about onto failures here, as it will have been done upstream
+        if onto_iri:
+            last_mod_date = onto_client.get_last_modification_date(project_iri_lookup.project_iri, onto_iri)
+            problems = _add_all_cardinalities_for_one_onto(
+                cardinalities=onto.cardinalities,
+                onto_iri=URIRef(onto_iri),
+                last_modification_date=last_mod_date,
+                onto_client=onto_client,
+                created_iris=created_iris,
+            )
+            all_problems.extend(problems)
+    if all_problems:
+        return CollectedProblems("During the cardinality creation the following problems occurred:", all_problems)
+    return None
+
+
+def _add_all_cardinalities_for_one_onto(
+    cardinalities: list[ParsedClassCardinalities],
+    onto_iri: URIRef,
+    last_modification_date: Literal,
+    onto_client: OntologyClient,
+    created_iris: CreatedIriCollection,
+) -> list[CreateProblem]:
+    problems: list[CreateProblem] = []
+    for c in cardinalities:
+        # we do not inform about classes failures here, as it will have been done upstream
+        if c.class_iri not in created_iris.classes:
+            logger.warning(f"CARDINALITY: Class '{c.class_iri}' not in successes, no cardinalities added.")
+            continue
+        last_modification_date, creation_problems = _add_cardinalities_for_one_class(
+            resource_card=c,
+            onto_iri=onto_iri,
+            last_modification_date=last_modification_date,
+            onto_client=onto_client,
+            successful_props=created_iris.properties,
+        )
+        problems.extend(creation_problems)
+    return problems
+
+
+def _add_cardinalities_for_one_class(
+    resource_card: ParsedClassCardinalities,
+    onto_iri: URIRef,
+    last_modification_date: Literal,
+    onto_client: OntologyClient,
+    successful_props: set[str],
+) -> tuple[Literal, list[UploadProblem]]:
+    res_iri = URIRef(resource_card.class_iri)
+    problems = []
+    for one_card in resource_card.cards:
+        if one_card.propname not in successful_props:
+            logger.warning(f"CARDINALITY: Property '{one_card.propname}' not in successes, no cardinality added.")
+            continue
+        last_modification_date, problem = _add_one_cardinality(
+            one_card, res_iri, onto_iri, last_modification_date, onto_client
+        )
+        if problem:
+            problems.append(problem)
+    return last_modification_date, problems
+
+
+def _add_one_cardinality(
+    card: ParsedPropertyCardinality,
+    res_iri: URIRef,
+    onto_iri: URIRef,
+    last_modification_date: Literal,
+    onto_client: OntologyClient,
+) -> tuple[Literal, UploadProblem | None]:
+    card_serialised = _serialise_card(card, res_iri, onto_iri, last_modification_date)
+    new_mod_date = onto_client.post_resource_cardinalities(card_serialised)
+    if not new_mod_date:
+        prefixed_cls = from_dsp_iri_to_prefixed_iri(str(res_iri))
+        prefixed_prop = from_dsp_iri_to_prefixed_iri(card.propname)
+        return last_modification_date, UploadProblem(
+            f"{prefixed_cls} / {prefixed_prop}",
+            ProblemType.CARDINALITY_COULD_NOT_BE_ADDED,
+        )
+    return new_mod_date, None
+
+
+def _serialise_card(
+    card: ParsedPropertyCardinality, res_iri: URIRef, onto_iri: URIRef, last_modification_date: Literal
+) -> dict[str, Any]:
+    onto_g = make_ontology_base_graph(onto_iri, last_modification_date)
+    onto_serialised = next(iter(serialise_json(onto_g)))
+    card_g = _make_one_cardinality_graph(card, res_iri)
+    card_serialised = serialise_json(card_g)
+    onto_serialised["@graph"] = card_serialised
+    return onto_serialised

dsp_tools/commands/create/create_on_server/mappers.py

@@ -0,0 +1,12 @@
+from rdflib import OWL
+from rdflib import Literal
+
+from dsp_tools.commands.create.models.parsed_ontology import Cardinality
+from dsp_tools.commands.create.models.rdf_ontology import RdfCardinalityRestriction
+
+PARSED_CARDINALITY_TO_RDF = {
+    Cardinality.C_1: RdfCardinalityRestriction(OWL.cardinality, Literal(1)),
+    Cardinality.C_0_1: RdfCardinalityRestriction(OWL.maxCardinality, Literal(1)),
+    Cardinality.C_1_N: RdfCardinalityRestriction(OWL.minCardinality, Literal(1)),
+    Cardinality.C_0_N: RdfCardinalityRestriction(OWL.minCardinality, Literal(0)),
+}

dsp_tools/commands/create/models/input_problems.py

@@ -7,17 +7,26 @@ from enum import StrEnum
 @dataclass
 class CollectedProblems:
     header: str
-    problems: list[InputProblem]
+    problems: list[CreateProblem]
 
 
 @dataclass
-class InputProblem:
+class CreateProblem:
     problematic_object: str
     problem: ProblemType
 
 
+@dataclass
+class InputProblem(CreateProblem): ...
+
+
+@dataclass
+class UploadProblem(CreateProblem): ...
+
+
 class ProblemType(StrEnum):
     PREFIX_COULD_NOT_BE_RESOLVED = (
         "The prefix used is not defined in the 'prefix' section of the file, "
         "nor does it belong to one of the project ontologies."
     )
+    CARDINALITY_COULD_NOT_BE_ADDED = "The cardinality could not be added."

dsp_tools/commands/create/models/rdf_ontology.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rdflib import Literal
+from rdflib import URIRef
+
+
+@dataclass
+class RdfResourceCardinality:
+    resource_iri: URIRef
+    on_property: URIRef
+    cardinality: RdfCardinalityRestriction
+
+
+@dataclass
+class RdfCardinalityRestriction:
+    owl_property: URIRef
+    cardinality_value: Literal

dsp_tools/commands/create/models/server_project_info.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from dataclasses import field
+
+from dsp_tools.commands.create.constants import KNORA_API_STR
+
+
+@dataclass
+class ProjectIriLookup:
+    project_iri: str
+    onto_iris: dict[str, str] = field(default_factory=dict)
+
+    def add_onto(self, name: str, iri: str) -> None:
+        self.onto_iris[name] = iri
+
+    def get_onto_iri(self, name: str) -> str | None:
+        return self.onto_iris.get(name)
+
+
+@dataclass
+class CreatedIriCollection:
+    classes: set[str] = field(default_factory=set)
+    properties: set[str] = field(default_factory=set)
+
+    def __post_init__(self) -> None:
+        self.properties.update({f"{KNORA_API_STR}seqnum", f"{KNORA_API_STR}isPartOf"})

dsp_tools/commands/create/parsing/parse_ontology.py

@@ -2,7 +2,7 @@ from typing import Any
 from typing import cast
 
 from dsp_tools.commands.create.models.input_problems import CollectedProblems
-from dsp_tools.commands.create.models.input_problems import InputProblem
+from dsp_tools.commands.create.models.input_problems import CreateProblem
 from dsp_tools.commands.create.models.input_problems import ProblemType
 from dsp_tools.commands.create.models.parsed_ontology import Cardinality
 from dsp_tools.commands.create.models.parsed_ontology import ParsedClass
@@ -46,7 +46,7 @@ def parse_ontology(ontology_json: dict[str, Any], prefixes: dict[str, str]) -> P
 
 def _parse_properties(
     properties_list: list[dict[str, Any]], current_onto_prefix: str
-) -> tuple[list[ParsedProperty], list[InputProblem]]:
+) -> tuple[list[ParsedProperty], list[CreateProblem]]:
     parsed = []
     for prop in properties_list:
         parsed.append(ParsedProperty(f"{current_onto_prefix}{prop['name']}", prop))
@@ -55,7 +55,7 @@ def _parse_properties(
 
 def _parse_classes(
     classes_list: list[dict[str, Any]], current_onto_prefix: str
-) -> tuple[list[ParsedClass], list[InputProblem]]:
+) -> tuple[list[ParsedClass], list[CreateProblem]]:
     parsed = []
     for cls in classes_list:
         parsed.append(ParsedClass(f"{current_onto_prefix}{cls['name']}", cls))
@@ -64,7 +64,7 @@ def _parse_classes(
 
 def _parse_cardinalities(
     classes_list: list[dict[str, Any]], current_onto_prefix: str, prefixes: dict[str, str]
-) -> tuple[list[ParsedClassCardinalities], list[InputProblem]]:
+) -> tuple[list[ParsedClassCardinalities], list[CreateProblem]]:
     parsed = []
     failures = []
     for c in classes_list:
@@ -79,7 +79,7 @@ def _parse_cardinalities(
 
 def _parse_one_class_cardinality(
     cls_json: dict[str, Any], current_onto_prefix: str, prefixes: dict[str, str]
-) -> ParsedClassCardinalities | list[InputProblem]:
+) -> ParsedClassCardinalities | list[CreateProblem]:
     failures = []
     parsed = []
     for c in cls_json["cardinalities"]:
@@ -96,10 +96,10 @@ def _parse_one_class_cardinality(
 
 def _parse_one_cardinality(
     card_json: dict[str, str | int], current_onto_prefix: str, prefixes: dict[str, str]
-) -> ParsedPropertyCardinality | InputProblem:
+) -> ParsedPropertyCardinality | CreateProblem:
     prp_name = cast(str, card_json["propname"])
     if not (resolved := resolve_to_absolute_iri(prp_name, current_onto_prefix, prefixes)):
-        return InputProblem(prp_name, ProblemType.PREFIX_COULD_NOT_BE_RESOLVED)
+        return CreateProblem(prp_name, ProblemType.PREFIX_COULD_NOT_BE_RESOLVED)
     gui = cast(int | None, card_json.get("gui_order"))
     return ParsedPropertyCardinality(
         propname=resolved,

dsp_tools/commands/create/parsing/parse_project.py

@@ -56,7 +56,7 @@ def _parse_metadata(project_json: dict[str, Any]) -> ParsedProjectMetadata:
         longname=project_json["longname"],
         descriptions=project_json["descriptions"],
         keywords=project_json["keywords"],
-        enabled_licenses=project_json["enabled_licenses"],
+        enabled_licenses=project_json.get("enabled_licenses", []),
     )
 
 

dsp_tools/commands/create/parsing/parsing_utils.py

@@ -2,7 +2,7 @@ from typing import Any
 
 import regex
 
-from dsp_tools.commands.create.constants import KNORA_API
+from dsp_tools.commands.create.constants import KNORA_API_STR
 from dsp_tools.commands.create.constants import UNIVERSAL_PREFIXES
 from dsp_tools.utils.data_formats.uri_util import is_uri
 
@@ -14,7 +14,7 @@ def resolve_to_absolute_iri(prefixed: str, current_onto: str, prefix_lookup: dic
         return f"{current_onto}{prefixed.lstrip(':')}"
     segments = prefixed.split(":", maxsplit=1)
     if len(segments) == 1:
-        return f"{KNORA_API}{segments[0]}"
+        return f"{KNORA_API_STR}{segments[0]}"
     if not (found := prefix_lookup.get(segments[0])):
         return None
     return f"{found}{segments[1]}"

dsp_tools/commands/create/serialisation/ontology.py

@@ -0,0 +1,41 @@
+from rdflib import OWL
+from rdflib import RDF
+from rdflib import RDFS
+from rdflib import BNode
+from rdflib import Graph
+from rdflib import Literal
+from rdflib import URIRef
+
+from dsp_tools.commands.create.constants import SALSAH_GUI
+from dsp_tools.commands.create.create_on_server.mappers import PARSED_CARDINALITY_TO_RDF
+from dsp_tools.commands.create.models.parsed_ontology import ParsedPropertyCardinality
+from dsp_tools.utils.rdflib_constants import KNORA_API
+
+
+def make_ontology_base_graph(onto_iri: URIRef, last_modification_date: Literal) -> Graph:
+    g = Graph()
+    g.add((onto_iri, RDF.type, OWL.Ontology))
+    g.add((onto_iri, KNORA_API.lastModificationDate, last_modification_date))
+    return g
+
+
+def make_cardinality_graph_for_request(
+    card: ParsedPropertyCardinality, res_iri: URIRef, onto_iri: URIRef, last_modification_date: Literal
+) -> Graph:
+    g = make_ontology_base_graph(onto_iri, last_modification_date)
+    g += _make_one_cardinality_graph(card, res_iri)
+    return g
+
+
+def _make_one_cardinality_graph(card: ParsedPropertyCardinality, res_iri: URIRef) -> Graph:
+    card_info = PARSED_CARDINALITY_TO_RDF[card.cardinality]
+    g = Graph()
+    bn_card = BNode()
+    g.add((res_iri, RDF.type, OWL.Class))
+    g.add((res_iri, RDFS.subClassOf, bn_card))
+    g.add((bn_card, RDF.type, OWL.Restriction))
+    g.add((bn_card, card_info.owl_property, card_info.cardinality_value))
+    g.add((bn_card, OWL.onProperty, URIRef(card.propname)))
+    if card.gui_order is not None:
+        g.add((bn_card, SALSAH_GUI.guiOrder, Literal(card.gui_order)))
+    return g