dump-things-service 0.2.0__py3-none-any.whl

datalad-concepts/patches/jsonschemagen_mixins.diff

@@ -0,0 +1,28 @@
+This patch has been proposed for inclusion into linkml
+https://github.com/linkml/linkml/pull/1935
+However, it may be a too simple approach.
+
+Specifically, the JSON schema output generated from our
+datalad-dataset-components schema referenced any base classes that were not
+abstract, but did not include definitions for mixin classes.
+
+This change aligns the criterion to exclude abstract, but not mixin
+classes.
+
+It may be possible to exclude the references to mixin classes in the JSON
+schema output, and thereby be able to continue to exclude definitions
+for mixin classes too. However, an attempt to address this in
+`get_type_info_for_slot_subschema()` was not fully successful for me,
+but was impacted by generator parametrization.
+--- jsonschemagen.py	2024-02-21 08:55:38.699043981 +0100
++++ jsonschemagen.py	2024-02-21 08:55:10.127030454 +0100
+@@ -225,7 +225,8 @@
+         )
+ 
+     def handle_class(self, cls: ClassDefinition) -> None:
+-        if cls.mixin or cls.abstract:
++        #if cls.mixin or cls.abstract:
++        if cls.abstract:
+             return
+ 
+         subschema_type = "object"

datalad-concepts/patches/jsonschemavalidator_plainyaml.diff

@@ -0,0 +1,34 @@
+See https://github.com/linkml/linkml/issues/1806 for
+problem and rationale re this patch
+--- jsonschemavalidator.py	2024-02-23 16:19:45.946867800 +0100
++++ jsonschemavalidator.py	2024-02-23 16:18:26.363624044 +0100
+@@ -187,7 +187,27 @@
+         inargs["fmt"] = input_format
+ 
+     try:
+-        data_as_dict = loader.load_as_dict(source=input, **inargs)
++        if input_format == 'yaml':
++            from io import StringIO
++            from hbreader import FileInfo
++            import os
++            import yaml
++            metadata = FileInfo()
++            data = loader._read_source(
++                input,
++                metadata=metadata,
++                accept_header="text/yaml, application/yaml;q=0.9",
++            )
++            if isinstance(data, str):
++                data = StringIO(data)
++                if metadata and metadata.source_file:
++                    data.name = os.path.relpath(metadata.source_file,
++                                                metadata.base_path)
++                data_as_dict = yaml.load(data, yaml.BaseLoader)
++            else:
++                data_as_dict = data
++        else:
++            data_as_dict = loader.load_as_dict(source=input, **inargs)
+     except NotImplementedError:
+         obj = loader.load(source=input, target_class=py_target_class, **inargs)
+         data_as_dict = as_simple_dict(obj)
+

datalad-concepts/patches/linkml_runtime_utils_yamlutils.diff

@@ -0,0 +1,29 @@
+This patch has been proposed for inclusion in linkml-runtime
+in https://github.com/linkml/linkml-runtime/pull/392
+
+
+fix type instantiation in _normalize_inlined
+    
+This commit fixes a problem that was discovered while
+converting between TTL and JSON using the schema
+https://concepts.inm7.de/s/simpleinput/unreleased.yaml
+    
+The original code used a dictionary as argument to
+the constructor of a pydantic-class, when it should
+have used the **-operator to cnvert the dictionary
+into keyword arguments.
+
+diff --git a/linkml_runtime/utils/yamlutils.py b/linkml_runtime/utils/yamlutils.py
+index 8ca8b30..d309091 100644
+--- a/linkml_runtime/utils/yamlutils.py
++++ b/linkml_runtime/utils/yamlutils.py
+@@ -169,7 +169,7 @@ class YAMLRoot(JsonObj):
+                         for lek, lev in items(list_entry):
+                             if lek == key_name and not isinstance(lev, (list, dict, JsonObj)):
+                                 # key_name:value
+-                                order_up(list_entry[lek], slot_type(list_entry))
++                                order_up(list_entry[lek], slot_type(**list_entry))
+                                 break   # Not strictly necessary, but
+                             elif not isinstance(lev, (list, dict, JsonObj)):
+                                 # key: value --> slot_type(key, value)
+

datalad-concepts/patches/rdflib_dumper_canonical.diff

@@ -0,0 +1,22 @@
+Make linkml-convert produce deterministic RDF output.
+See https://github.com/linkml/linkml/issues/1943 for details
+and caveats
+--- rdflib_dumper.py	2024-02-24 07:36:07.532183567 +0100
++++ rdflib_dumper.py	2024-02-24 07:36:26.279874637 +0100
+@@ -6,6 +6,7 @@
+ 
+ from curies import Converter
+ from rdflib import Graph, URIRef, XSD
++from rdflib.compare import to_canonical_graph
+ from rdflib.term import Node, BNode, Literal
+ from rdflib.namespace import RDF
+ 
+@@ -66,7 +67,7 @@
+         if schemaview.namespaces()._base:
+             g.base = schemaview.namespaces()._base
+         self.inject_triples(element, schemaview, g)
+-        return g
++        return to_canonical_graph(g)
+ 
+     def inject_triples(self, element: Any, schemaview: SchemaView, graph: Graph, target_type: ElementName = None) -> Node:
+         """

datalad-concepts/patches/rdflib_loader_typedesignator.diff

@@ -0,0 +1,27 @@
+# Populate type-designator slots from graph
+# (for inlined blank-nodes -- but actuallu unclear how the issue reaches).
+#
+# Example of a record it could not handle without this patch (failing to
+# encode `IssuedIdentifier` being the actual type of the identifier.
+#
+# @prefix dlidentifiers: <https://concepts.datalad.org/s/identifiers/unreleased/> .
+# @prefix dlsocial: <https://concepts.datalad.org/s/social/unreleased/> .
+# @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+#
+# <https://trr379.de/contributors/michael-hanke> a dlsocial:Person ;
+#     dlidentifiers:identifier [ a dlidentifiers:IssuedIdentifier ;
+#             dlidentifiers:creator "https://orcid.org"^^xsd:anyURI ;
+#             dlidentifiers:notation "0000-0001-6398-6370" ;
+#             dlidentifiers:schema_agency "Open Researcher and Contributor ID organization" ] ;
+#     dlsocial:given_name "Michael" ;
+#
+--- rdflib_loader.py      2025-02-10 01:09:21.627350190 +0100
++++ rdflib_loader.py      2025-02-10 01:10:15.593488451 +0100
+@@ -106,6 +106,7 @@
+                         raise ValueError(f'Ambiguous types for {subject} == {type_classes}')
+                     logger.info(f'Replacing {subject_class} with {type_classes}')
+                     subject_class = type_classes[0].name
++                    dict_obj[type_designator_slot.name] = type_classes[0].class_uri
+             # process all triples for this node
+             for (_, p, o) in graph.triples((subject, None, None)):
+                 processed_triples.add((subject,p,o))

datalad-concepts/patches/shacl_ifabsent.diff

@@ -0,0 +1,14 @@
+This patches shacl_ifabsent_processor.py by adding ifabsent handling for the
+uriorcurie type, which is needed for the 'creator' slot in the identifiers schema
+--- shacl_ifabsent_processor.py
++++ shacl_ifabsent_processor.py
+@@ -62,7 +62,8 @@ class ShaclIfAbsentProcessor(IfAbsentProcessor):
+         return Literal(f"{year}-{month}-{day}T{hour}:{minutes}:{seconds}", datatype=ShaclDataType.DATETIME.uri_ref)
+ 
+     def map_uri_or_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+-        raise NotImplementedError()
++        uri = URIRef(self.schema_view.expand_curie(default_value))
++        return Literal(uri, datatype=ShaclDataType.URI.uri_ref)
+ 
+     def map_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+         return Literal(default_value, datatype=ShaclDataType.CURIE.uri_ref)

datalad-concepts/patches/shaclgen_annotations.diff

@@ -0,0 +1,63 @@
+This patches shaclgen.py to allow improved handling of slot annotations and sh:order.
+Firstly, it introduces the --exclude-order flag that allows to completely disable the
+automatic assignment of the sh:order field to exported property shapes. See:
+https://github.com/psychoinformatics-de/shacl-vue/issues/107#issuecomment-2866073117
+Secondly, if the --exclude-order flag is not used, the patch prevents creation of faulty
+sh:order lists by prioritizing sh:order provided via annotation, since sh:order should
+just be a single numerical value. See for context:
+https://github.com/linkml/linkml/pull/2111#issuecomment-2116208229
+Lastlt, and for a similar reason as before, it only sets sh:path automatically if the
+value has not already been set via annotation.
+--- shaclgen.py
++++ shaclgen.py
+@@ -30,6 +30,8 @@ class ShaclGenerator(Generator):
+     """parameterized suffix to be appended. No suffix per default."""
+     include_annotations: bool = False
+     """True means include all class / slot / type annotations in generated Node or Property shapes"""
++    exclude_order: bool = False
++    """True means exclude the automatic addition of sh:order to Property shapes"""
+     exclude_imports: bool = False
+     """If True, elements from imported ontologies won't be included in the generator's output"""
+     generatorname = os.path.basename(__file__)
+@@ -114,8 +116,6 @@ class ShaclGenerator(Generator):
+                         g.add((pnode, p, Literal(v)))
+ 
+                 prop_pv(SH.path, slot_uri)
+-                prop_pv_literal(SH.order, order)
+-                order += 1
+                 prop_pv_literal(SH.name, s.title)
+                 prop_pv_literal(SH.description, s.description)
+                 # minCount
+@@ -223,6 +223,18 @@ class ShaclGenerator(Generator):
+                 default_value = ifabsent_processor.process_slot(s, c)
+                 if default_value:
+                     prop_pv(SH.defaultValue, default_value)
++                
++                # Add the order automatically unless the --exclude-order flag was supplied
++                if not self.exclude_order:
++                    # sh:order may already have been added to the graph via annotations
++                    if not (pnode, SH.order, None) in g:
++                        prop_pv_literal(SH.order, order)
++                        order += 1
++                
++                # sh:path may already have been added to the graph via annotations
++                if not (pnode, SH.path, None) in g:
++                    prop_pv(SH.path, slot_uri)
++                
+ 
+         return g
+ 
+@@ -366,6 +378,13 @@ def add_simple_data_type(func: Callable, r: ElementName) -> None:
+     show_default=True,
+     help="Use --include-annotations to include annotations of slots, types, and classes in the generated SHACL shapes.",
+ )
++@click.option(
++    "--exclude-order/--include-order",
++    default=False,
++    show_default=True,
++    help="Use --exclude-order to exclude sh:order from being added automatically to generated SHACL property shapes. "
++    "Default behavior adds order. This flag has no influence on sh:order being added via annotations.",
++)
+ @click.option(
+     "--exclude-imports/--include-imports",
+     default=False,

datalad-concepts/tools/patch_linkml

@@ -0,0 +1,18 @@
+#!/bin/bash
+#
+# This script applies patches to the active linkml installation.
+# It is to be executed in the root of the repository.
+#
+
+# make JSON schema generation work with mixins
+patch -d $(python -c 'import os; import linkml.generators.jsonschemagen as m; print(os.path.dirname(m.__file__))') < patches/jsonschemagen_mixins.diff
+#patch -d $(python -c 'import os; import linkml.validators.jsonschemavalidator as m; print(os.path.dirname(m.__file__))') < patches/jsonschemavalidator_plainyaml.diff
+#patch -d $(python -c 'import os; import linkml_runtime.dumpers as m; print(os.path.dirname(m.__file__))') < patches/rdflib_dumper_canonical.diff
+# Create correct 'order' properties when generating SHACL
+patch -d $(python -c 'import os; import linkml.generators.shaclgen as m; print(os.path.dirname(m.__file__))') < patches/shaclgen_annotations.diff
+# Allow ifabsent handling of uriorcurie type during SHACL generation
+patch -d $(python -c 'import os; import linkml.generators.shacl.shacl_ifabsent_processor as m; print(os.path.dirname(m.__file__))') < patches/shacl_ifabsent.diff
+# Honor type-designator slots when loading graphs
+patch -d $(python -c 'import os; import linkml_runtime.loaders as m; print(os.path.dirname(m.__file__))') < patches/rdflib_loader_typedesignator.diff
+# Use correct constructor arguments when normalizing inlined objects
+patch -d $(python -c 'import os; import linkml_runtime.utils.yamlutils as m; print(os.path.dirname(m.__file__))') < patches/linkml_runtime_utils_yamlutils.diff

dump_things_service/__about__.py

@@ -0,0 +1 @@
+__version__ = '0.2.0'

dump_things_service/__init__.py

@@ -0,0 +1,38 @@
+from enum import Enum
+from typing import (
+    Any,
+    Union,
+)
+
+from starlette.status import (
+    HTTP_200_OK,
+    HTTP_400_BAD_REQUEST,
+    HTTP_401_UNAUTHORIZED,
+    HTTP_403_FORBIDDEN,
+    HTTP_404_NOT_FOUND,
+    HTTP_500_INTERNAL_SERVER_ERROR,
+)
+
+__all__ = [
+    'Format',
+    'HTTP_200_OK',
+    'HTTP_400_BAD_REQUEST',
+    'HTTP_401_UNAUTHORIZED',
+    'HTTP_403_FORBIDDEN',
+    'HTTP_404_NOT_FOUND',
+    'HTTP_500_INTERNAL_SERVER_ERROR',
+    'JSON',
+    'YAML',
+    'config_file_name',
+]
+
+
+class Format(str, Enum):
+    json = 'json'
+    ttl = 'ttl'
+
+
+JSON = Union[dict[str, Any], list[Any], str, int, float, None]
+YAML = JSON
+
+config_file_name = '.dumpthings.yaml'