maplib 0.14.5__cp39-none-win_amd64.whl → 0.17.8__cp39-none-win_amd64.whl

maplib/__init__.py

@@ -1,8 +1,60 @@
-import pathlib
+# r'''
+# # Overview
+#
+# '''
+
+__all__ = [
+    "Model",
+    "a",
+    "Triple",
+    "SolutionModels",
+    "IndexingOptions",
+    "ValidationReport",
+    "Instance",
+    "Template",
+    "Argument",
+    "Parameter",
+    "Variable",
+    "RDFType",
+    "XSD",
+    "IRI",
+    "Literal",
+    "Prefix",
+    "BlankNode",
+    "explore",
+    "add_triples",
+    "MaplibException",
+]
 
+import pathlib
 from .maplib import *
-from .add_triples import add_triples
-PATH_HERE = pathlib.Path(__file__).parent.resolve()
+from .adding_triples import add_triples
+
+if (pathlib.Path(__file__).parent.resolve() / "graph_explorer").exists():
+    from .graph_explorer import explore
+else:
+
+    def explore(
+        m: "Model",
+        host: str = "localhost",
+        port: int = 8000,
+        bind: str = "localhost",
+        popup=True,
+        fts=True,
+    ):
+        """Starts a graph explorer session.
+        To run from Jupyter Notebook use:
+        >>> from maplib import explore
+        >>>
+        >>> server = explore(m)
+        You can later stop the server with
+        >>> server.stop()
 
-if (PATH_HERE / "graph_explorer").exists():
-    from .graph_explorer import explore
+        :param m: The Model to explore
+        :param host: The hostname that we will point the browser to.
+        :param port: The port where the graph explorer webserver listens on.
+        :param bind: Bind to the following host / ip.
+        :param popup: Pop up the browser window.
+        :param fts: Enable full text search indexing
+        """
+        print("Contact Data Treehouse to try!")

maplib/{maplib.pyi → __init__.pyi}

@@ -68,16 +68,16 @@ class Prefix:
     A prefix that can be used to ergonomically build iris.
     """
 
-    def __init__(self, prefix, iri):
+    def __init__(self, iri,  prefix_name=None):
         """
         Create a new prefix.
-        :param prefix: The name of the prefix
         :param iri: The prefix IRI.
+        :param prefix_name: The name of the prefix
         """
 
     def suf(self, suffix: str) -> IRI:
         """
-        Create a IRI by appending the suffix.
+        Create an IRI by appending the suffix.
         :param suffix: The suffix to append.
         :return:
         """
@@ -250,15 +250,18 @@ class IndexingOptions:
     Options for indexing
     """
 
-    def __init__(self, enabled:bool=True,
-                 object_sort_all:bool=None,
-                 object_sort_some:List["IRI"]=None):
+    def __init__(
+        self,
+        object_sort_all: bool = None,
+        object_sort_some: List["IRI"] = None,
+        fts_path: str = None,
+    ):
         """
         Defaults to indexing on subjects and objects for select types (e.g. rdf:type and rdfs:label)
 
-        :param enabled: Enable indexing (this will enable indexing on subjects)
         :param object_sort_all: Enable object-indexing for all suitable predicates (doubles memory requirement).
         :param object_sort_some: Enable object-indexing for a selected list of predicates.
+        :param fts_path: Enable full text search, stored at the path
         """
 
 ParametersType = Dict[str, Tuple[DataFrame, Dict[str, RDFType]]]
@@ -270,17 +273,26 @@ class ValidationReport:
     """
 
     conforms: bool
+    "Whether or not the validation report conforms to the shapes"
+
+    shape_targets: DataFrame
+    "A DataFrame containing the counts of the targets of each shape and constraint"
+
+    performance: DataFrame
+    "Performance statistics for the validation process"
 
     def results(
         self,
         native_dataframe: bool = False,
         include_datatypes: bool = False,
-    ) -> Optional[Union[DataFrame, SolutionMappings]]:
+        streaming: bool = False,
+    ) -> Optional[Union[DataFrame, "SolutionMappings"]]:
         """
         Return the results of the validation report, if they exist.
 
         :param native_dataframe: Return columns with maplib-native formatting. Useful for round-trips.
         :param include_datatypes: Return datatypes of the results DataFrame (returns SolutionMappings instead of DataFrame).
+        :param streaming: Use the Polars streaming functionality.
         :return: The SHACL validation report, as a DataFrame
         """
 
@@ -288,6 +300,7 @@ class ValidationReport:
         self,
         native_dataframe: bool = False,
         include_datatypes: bool = False,
+        streaming: bool = False,
     ) -> Optional[DataFrame]:
         """
         Returns the details of the validation report.
@@ -295,20 +308,19 @@ class ValidationReport:
 
         :param native_dataframe: Return columns with maplib-native formatting. Useful for round-trips.
         :param include_datatypes: Return datatypes of the results DataFrame (returns SolutionMappings instead of DataFrame).
+        :param streaming: Use the Polars streaming functionality.
         :return: Details of the SHACL validation report, as a DataFrame
         """
 
-    def graph(self, indexing = None) -> "Mapping":
+    def graph(self) -> "Mapping":
         """
         Creates a new mapping object where the base graph is the validation report with results.
         Includes the details of the validation report in the new graph if they exist.
 
-        :param indexing: Should the constructed graph be indexed?
-                         If not specified it is inherited from the mapping where validate was called.
         :return:
         """
 
-class Mapping:
+class Model:
     """
     A mapping session allowing:
 
@@ -318,80 +330,99 @@ class Mapping:
 
     Usage:
 
-    >>> from maplib import Mapping
+    >>> from maplib import Model
     ... doc = '''
     ... :prefix ex:<http://example.net/ns#>.
     ... ex:ExampleTemplate [?MyValue] :: {
     ...    ottr:Triple(ex:myObject, ex:hasValue, ?MyValue)
     ... } .'''
-    ... m = Mapping(doc)
+    ... m = Model()
+    ... m.add_template(doc)
 
     :param documents: a stOTTR document or a list of these
     :param indexing_options: options for indexing
     """
 
     def __init__(
-        self, documents: Union[str, List[str]] = None, indexing_options: "IndexingOptions" = None
-    ) -> "Mapping": ...
-    def add_template(self, template: "Template"):
+        self,
+        indexing_options: "IndexingOptions" = None,
+    ) -> "Model": ...
+    def add_template(self, template: Union["Template", str]):
         """
-        Add a template to the mapping. Overwrites any existing template with the same IRI.
-        :param template: The template to add.
+        Add a template to the model. Overwrites any existing template with the same IRI.
+        :param template: The template to add, as a stOTTR string or as a programmatically constructed Template.
         :return:
         """
 
-    def expand(
+    def map(
         self,
         template: Union[str, "Template", IRI],
         df: DataFrame = None,
-        unique_subset: List[str] = None,
         graph: str = None,
         types: Dict[str, RDFType] = None,
         validate_iris: bool = True,
-        validate_unique_subset: bool = False,
     ) -> None:
         """
-        Expand a template using a DataFrame
+        Map a template using a DataFrame
         Usage:
 
-        >>> m.expand("ex:ExampleTemplate", df)
-        ... m.expand("ex:ExampleTemplate", df, unique_subsets=["MyValue"])
+        >>> m.map("ex:ExampleTemplate", df)
 
         If the template has no arguments, the df argument is not necessary.
 
         :param template: Template, IRI, IRI string or prefixed template name.
         :param df: DataFrame where the columns have the same names as the template arguments
-        :param unique_subset: DataFrame column names known to be unique e.g. ["colA", "colB"], for a performance boost (reduce costly deduplication)
         :param graph: The IRI of the graph to add triples to.
+        :param types: The types of the columns.
         :param validate_iris: Validate any IRI-columns.
-        :param validate_unique_subset: Check that provided unique subset actually is unique.
+        """
+
+    def map_triples(
+        self,
+        df: DataFrame = None,
+        predicate: str = None,
+        graph: str = None,
+        types: Dict[str, RDFType] = None,
+        validate_iris: bool = True,
+    ) -> None:
+        """
+        Map a template using a DataFrame with columns subject, object and predicate
+        The predicate column can also be supplied as a string if it is the same for all rows.
+        Usage:
+
+        >>> m.map_triples(df)
+
+        If the template has no arguments, the df argument is not necessary.
+
+        :param df: DataFrame where the columns are named subject and object. May also contain a verb-column.
+        :param verb: The uri of the verb.
+        :param graph: The IRI of the graph to add triples to.
         :param types: The types of the columns.
+        :param validate_iris: Validate any IRI-columns.
         """
 
-    def expand_default(
+    def map_default(
         self,
         df: DataFrame,
         primary_key_column: str,
-        template_prefix: str = None,
-        predicate_uri_prefix: str = None,
+        dry_run: bool = False,
         graph: str = None,
+        types: Dict[str, RDFType] = None,
         validate_iris: bool = True,
-        validate_unique_subset: bool = False,
     ) -> str:
         """
-        Create a default template and expand it based on a dataframe.
+        Create a default template and map it based on a dataframe.
         Usage:
 
-        >>> template_string = m.expand_default(df, "myKeyCol")
+        >>> template_string = m.map_default(df, "myKeyCol")
         ... print(template_string)
 
         :param df: DataFrame where the columns have the same names as the template arguments
         :param primary_key_column: This column will be the subject of all triples in the generated template.
-        :param template_prefix: Prefix of the template - the name is auto-generated.
-        :param predicate_uri_prefix: Prefix of the predicates/verbs in the generated template, names are derived from column names.
+        :param dry_run: Do not map the template, only return the string.
         :param graph: The IRI of the graph to add triples to.
+        :param types: The types of the columns.
         :param validate_iris: Validate any IRI-columns.
-        :param validate_unique_subset: Check that provided unique subset actually is unique.
         :return: The generated template
         """
 
@@ -404,6 +435,7 @@ class Mapping:
         graph: str = None,
         streaming: bool = False,
         return_json: bool = False,
+        include_transient: bool = True,
     ) -> Union[
         DataFrame, SolutionMappings, List[Union[DataFrame, SolutionMappings, str]], None
     ]:
@@ -412,7 +444,7 @@ class Mapping:
         Currently, SELECT, CONSTRUCT and INSERT are supported.
         Usage:
 
-        >>> df = mapping.query('''
+        >>> df = model.query('''
         ... PREFIX ex:<http://example.net/ns#>
         ... SELECT ?obj1 ?obj2 WHERE {
         ...    ?obj1 ex:hasObj ?obj2
@@ -426,25 +458,54 @@ class Mapping:
         :param graph: The IRI of the graph to query.
         :param streaming: Use Polars streaming
         :param return_json: Return JSON string.
+        :param include_transient: Include transient triples when querying.
         :return: DataFrame (Select), list of DataFrames (Construct) containing results, or None for Insert-queries
 
         """
 
+    def update(
+            self,
+            update: str,
+            parameters: ParametersType = None,
+            streaming: bool = False,
+            include_transient: bool = True,
+    ):
+        """
+        Insert the results of a Construct query in the graph.
+        Useful for being able to use the same query for inspecting what will be inserted and actually inserting.
+        Usage:
+
+        >>> m = Model(doc)
+        ... # Omitted
+        ... update_pizzas = '''
+        ... ...'''
+        ... m.update(update_pizzas)
+
+        :param update: The SPARQL Update string
+        :param parameters: PVALUES Parameters, a DataFrame containing the value bindings in the custom PVALUES construction.
+        :param streaming: Use Polars streaming
+        :param include_transient: Include transient triples when querying (but see "transient" above).
+        :return: None
+        """
+
     def insert(
         self,
         query: str,
         parameters: ParametersType = None,
+        include_datatypes: bool = False,
+        native_dataframe: bool = False,
         transient: bool = False,
         streaming: bool = False,
         source_graph: str = None,
         target_graph: str = None,
+        include_transient: bool = True,
     ):
         """
         Insert the results of a Construct query in the graph.
         Useful for being able to use the same query for inspecting what will be inserted and actually inserting.
         Usage:
 
-        >>> m = Mapping(doc)
+        >>> m = Model(doc)
         ... # Omitted
         ... hpizzas = '''
         ... PREFIX pizza:<https://github.com/magbak/maplib/pizza#>
@@ -458,10 +519,13 @@ class Mapping:
 
         :param query: The SPARQL Insert query string
         :param parameters: PVALUES Parameters, a DataFrame containing the value bindings in the custom PVALUES construction.
-        :param transient: Should the inserted triples be included in exports?
+        :param native_dataframe: Return columns with maplib-native formatting. Useful for round-trips.
+        :param include_datatypes: Datatypes are not returned by default, set to true to return a dict with the solution mappings and the datatypes.
+        :param transient: Should the inserted triples be transient?
         :param source_graph: The IRI of the source graph to execute the construct query.
         :param target_graph: The IRI of the target graph to insert into.
         :param streaming: Use Polars streaming
+        :param include_transient: Include transient triples when querying (but see "transient" above).
         :return: None
         """
 
@@ -472,6 +536,10 @@ class Mapping:
         include_conforms: bool = False,
         include_shape_graph: bool = True,
         streaming: bool = False,
+        max_shape_constraint_results: int = None,
+        only_shapes: List[str] = None,
+        deactivate_shapes: List[str] = None,
+        dry_run: bool = False,
     ) -> ValidationReport:
         """
         Validate the contained knowledge graph using SHACL
@@ -483,18 +551,21 @@ class Mapping:
         :param include_shape_graph: Include the shape graph in the report, useful when creating the graph from the report.
         :param include_datatypes: Return the datatypes of the validation report (and details).
         :param streaming: Use Polars streaming
+        :param max_shape_constraint_results: Maximum number of results per shape and constraint. Reduces the size of the result set.
+        :param only_shapes: Validate only these shapes, None means all shapes are validated (must be IRI, cannot be used with deactivate_shapes).
+        :param deactivate_shapes: Disable validation of these shapes (must be IRI, cannot be used with deactivate_shapes).
+        :param dry_run: Only find targets of shapes, but do not validate them.
         :return: Validation report containing a report (report.df) and whether the graph conforms (report.conforms)
         """
 
-    def read_triples(
+    def read(
         self,
         file_path: Union[str, Path],
         format: LiteralType["ntriples", "turtle", "rdf/xml", "xml", "rdfxml"] = None,
         base_iri: str = None,
         transient: bool = False,
-        parallel: bool = False,
+        parallel: bool = None,
         checked: bool = True,
-        deduplicate: bool = True,
         graph: str = None,
         replace_graph: bool = False,
     ) -> None:
@@ -506,28 +577,26 @@ class Mapping:
 
         Usage:
 
-        >>> m.read_triples("my_triples.ttl")
+        >>> m.read("my_triples.ttl")
 
         :param file_path: The path of the file containing triples
         :param format: One of "ntriples", "turtle", "rdf/xml", otherwise it is inferred from the file extension.
         :param base_iri: Base iri
         :param transient: Should these triples be included when writing the graph to the file system?
-        :param parallel: Parse triples in parallel, currently only NTRiples. Assumes all prefixes are in the beginning of the document.
+        :param parallel: Parse triples in parallel, currently only NTRiples and Turtle. Assumes all prefixes are in the beginning of the document. Defaults to true only for NTriples.
         :param checked: Check IRIs etc.
-        :param deduplicate: Set to true by default, disable to increase throughput for large files containing only unique triples.
         :param graph: The IRI of the graph to read the triples into, if None, it will be the default graph.
         :param replace_graph: Replace the graph with these triples? Will replace the default graph if no graph is specified.
         """
 
-    def read_triples_string(
+    def reads(
         self,
         s: str,
         format: LiteralType["ntriples", "turtle", "rdf/xml", "xml", "rdfxml"],
         base_iri: str = None,
         transient: bool = False,
-        parallel: bool = False,
+        parallel: bool = None,
         checked: bool = True,
-        deduplicate: bool = True,
         graph: str = None,
         replace_graph: bool = False,
     ) -> None:
@@ -538,66 +607,84 @@ class Mapping:
 
         Usage:
 
-        >>> m.read_triples(my_ntriples_string, format="ntriples")
+        >>> m.reads(my_ntriples_string, format="ntriples")
 
         :param s: String containing serialized triples.
         :param format: One of "ntriples", "turtle", "rdf/xml".
         :param base_iri: Base iri
         :param transient: Should these triples be included when writing the graph to the file system?
-        :param parallel: Parse triples in parallel, currently only NTRiples. Assumes all prefixes are in the beginning of the document.
+        :param parallel: Parse triples in parallel, currently only NTRiples and Turtle. Assumes all prefixes are in the beginning of the document. Defaults to true for NTriples.
         :param checked: Check IRIs etc.
-        :param deduplicate: Set to true by default, disable to increase throughput for large files containing only unique triples.
         :param graph: The IRI of the graph to read the triples into.
         :param replace_graph: Replace the graph with these triples? Will replace the default graph if no graph is specified.
         """
 
-    def write_ntriples(self, file_path: Union[str, Path], graph: str = None) -> None:
+    def write_cim_xml(
+        self,
+        file_path: Union[str, Path],
+        profile_graph: str,
+        model_iri: str = None,
+        version: str = None,
+        description: str = None,
+        created: str = None,
+        scenario_time: str = None,
+        modeling_authority_set: str = None,
+        prefixes: Dict[str, str] = None,
+        graph: str = None,
+    ) -> None:
         """
-        DEPRECATED: use write_triples with format="ntriples"
-        Write the non-transient triples to the file path specified in the NTriples format.
-
-        Usage:
-
-        >>> m.write_ntriples("my_triples.nt")
+        Write the legacy CIM XML format.
+
+        >>> PROFILE_GRAPH = "urn:graph:profiles"
+        >>> m = Model()
+        >>> m.read(model_path, base_iri=publicID, format="rdf/xml")
+        >>> m.read("61970-600-2_Equipment-AP-Voc-RDFS2020_v3-0-0.rdf", graph=PROFILE_GRAPH, format="rdf/xml")
+        >>> m.read("61970-600-2_Operation-AP-Voc-RDFS2020_v3-0-0.rdf", graph=PROFILE_GRAPH, format="rdf/xml")
+        >>> m.write_cim_xml(
+        >>>     "model.xml",
+        >>>     profile_graph=PROFILE_GRAPH,
+        >>>     description = "MyModel",
+        >>>     created = "2023-09-14T20:27:41",
+        >>>     scenario_time = "2023-09-14T02:44:43",
+        >>>     modeling_authority_set="www.westernpower.co.uk",
+        >>>     version="22",
+        >>> )
 
         :param file_path: The path of the file containing triples
-        :param graph: The IRI of the graph to write.
-        """
-
-    def write_triples(self,
-            file_path: Union[str, Path],
-            format=LiteralType["ntriples", "turtle", "rdf/xml"],
-            graph: str = None,
-            ) -> None:
+        :param profile_graph: The IRI of the graph containing the ontology of the CIM profile to write.
+        :param model_iri: model_iri a md:FullModel. Is generated if not provided.
+        :param version: model_iri md:Model.version version .
+        :param description: model_iri md:Model.description description .
+        :param created: model_iri md:Model.created created .
+        :param scenario_time: model_iri md:Model.scenarioTime scenario_time .
+        :param modeling_authority_set: model_iri md:Model.modelingAuthoritySet modeling_authority_set .
+        :param prefixes: Prefixes to be used in XML export.
+        :param graph: The graph to write, defaults to the default graph.
+        """
+
+    def write(
+        self,
+        file_path: Union[str, Path],
+        format=LiteralType["ntriples", "turtle", "rdf/xml"],
+        graph: str = None,
+    ) -> None:
         """
         Write the non-transient triples to the file path specified in the NTriples format.
 
         Usage:
 
-        >>> m.write_triples("my_triples.nt", format="ntriples")
+        >>> m.write("my_triples.nt", format="ntriples")
 
         :param file_path: The path of the file containing triples
         :param format: One of "ntriples", "turtle", "rdf/xml".
         :param graph: The IRI of the graph to write.
         """
 
-
-    def write_ntriples_string(self, graph: str = None) -> str:
-        """
-        DEPRECATED: use write_triples_string with format="ntriples"
-        Write the non-transient triples to a string in memory.
-
-        Usage:
-
-        >>> s = m.write_ntriples_string()
-
-        :param graph: The IRI of the graph to write.
-        :return Triples in mapping in the NTriples format (potentially a large string)
-        """
-
-    def write_triples_string(self, format=LiteralType["ntriples", "turtle", "rdf/xml"], graph: str = None) -> str:
+    def writes(
+        self, format=LiteralType["ntriples", "turtle", "rdf/xml"], graph: str = None
+    ) -> str:
         """
-        DEPRECATED: use write_triples_string with format="ntriples"
+        DEPRECATED: use writes with format="ntriples"
         Write the non-transient triples to a string in memory.
 
         Usage:
@@ -606,7 +693,7 @@ class Mapping:
 
         :param format: One of "ntriples", "turtle", "rdf/xml".
         :param graph: The IRI of the graph to write.
-        :return Triples in mapping in the NTriples format (potentially a large string)
+        :return Triples in model in the NTriples format (potentially a large string)
         """
 
     def write_native_parquet(
@@ -626,7 +713,7 @@ class Mapping:
     def create_sprout(self):
         """
         A sprout is a simplified way of dealing with multiple graphs.
-        See also `maplib.maplib.Mapping.insert_sprout` and `maplib.maplib.Mapping.detach_sprout`
+        See also `Model.insert_sprout` and `Model.detach_sprout`
 
         :return:
         """
@@ -635,20 +722,24 @@ class Mapping:
         self,
         query: str,
         parameters: ParametersType = None,
+        include_datatypes: bool = False,
+        native_dataframe: bool = False,
         transient: bool = False,
         streaming: bool = False,
         source_graph: str = None,
         target_graph: str = None,
+        include_transient: bool = True,
     ):
         """
         Insert the results of a Construct query in a sprouted graph, which is created if no sprout is active.
         Sprouts are simplified way of dealing with multiple graphs.
         Useful for being able to use the same query for inspecting what will be inserted and actually inserting.
-        See also `maplib.maplib.Mapping.detach_sprout`
+        See also `Model.detach_sprout`
 
         Usage:
 
-        >>> m = Mapping(doc)
+        >>> m = Model()
+        ... m.add_template(doc)
         ... m.create_sprout()
         ... # Omitted
         ... hpizzas = '''
@@ -663,28 +754,35 @@ class Mapping:
 
         :param query: The SPARQL Insert query string
         :param parameters: PVALUES Parameters, a DataFrame containing the value bindings in the custom PVALUES construction.
+        :param native_dataframe: Return columns with maplib-native formatting. Useful for round-trips.
+        :param include_datatypes: Datatypes are not returned by default, set to true to return a dict with the solution mappings and the datatypes.
         :param transient: Should the inserted triples be included in exports?
         :param source_graph: The IRI of the source graph to execute the construct query.
         :param target_graph: The IRI of the target graph to insert into.
         :param streaming: Use Polars streaming
+        :param include_transient: Include transient triples when querying (see also "transient" above).
         :return: None
         """
 
-    def detach_sprout(self) -> "Mapping":
+    def detach_sprout(self) -> "Model":
         """
-        Detaches and returns the sprout from the mapping.
+        Detaches and returns the sprout from the model.
 
-        @return: The sprout as its own Mapping.
+        :return: The sprout as its own Model.
         """
 
-    def get_predicate_iris(self, graph: str = None, include_transient:bool=False) -> List["IRI"]:
+    def get_predicate_iris(
+        self, graph: str = None, include_transient: bool = False
+    ) -> List["IRI"]:
         """
         :param graph: The graph to get the predicate iris from.
         :param include_transient: Should we include predicates only between transient triples?
         :return: The IRIs of the predicates currently in the given graph.
         """
 
-    def get_predicate(self, iri: "IRI", graph: str=None, include_transient:bool=False) -> List["SolutionMappings"]:
+    def get_predicate(
+        self, iri: "IRI", graph: str = None, include_transient: bool = False
+    ) -> List["SolutionMappings"]:
         """
         :param iri: The predicate IRI
         :param graph: The graph to get the predicate from.
@@ -692,7 +790,9 @@ class Mapping:
         :return: A list of the underlying tables that store a given predicate.
         """
 
-    def create_index(self, options: "IndexingOptions"=None, all:bool=True, graph: str=None):
+    def create_index(
+        self, options: "IndexingOptions" = None, all: bool = True, graph: str = None
+    ):
         """
         :param options: Indexing options
         :param all: Apply to all existing and new graphs
@@ -700,9 +800,18 @@ class Mapping:
         :return:
         """
 
-    def initialize(self):
+    def infer(
+        self,
+        ruleset: Union[str, List[str]],
+        include_datatypes: bool = False,
+        native_dataframe: bool = False,
+    ) -> Optional[Dict[str, DataFrame]]:
         """
-        Deduplicates and builds indices of all triplestores.
-        Happens automatically on first query or validation.
-        :return:
+        Run the inference rules that are provided
+        :param ruleset: The Datalog ruleset (a string).
+        :param native_dataframe: Return columns with maplib-native formatting. Useful for round-trips.
+        :param include_datatypes: Datatypes are not returned by default, set to true to return a dict with the solution mappings and the datatypes.
+        :return: The inferred N-Tuples.
         """
+
+class MaplibException(Exception): ...

maplib/adding_triples.py

@@ -0,0 +1,29 @@
+from maplib.maplib import Model, Template, IRI, Triple, Variable
+
+
+def add_triples(
+    source: Model, target: Model, source_graph: str = None, target_graph: str = None
+):
+    """(Zero) copy the triples from one Model into another.
+
+    :param source: The source mapping
+    :param target: The target mapping
+    :param source_graph: The named graph in the source mapping to copy from. None means default graph.
+    :param target_graph: The named graph in the target mapping to copy into. None means default graph.
+    """
+    for p in source.get_predicate_iris(source_graph):
+        subject = Variable("subject")
+        object = Variable("object")
+        template = Template(
+            iri=IRI("urn:maplib:tmp"),
+            parameters=[subject, object],
+            instances=[Triple(subject, p, object)],
+        )
+        sms = source.get_predicate(p, source_graph)
+        for sm in sms:
+            target.map(
+                template,
+                sm.mappings,
+                types=sm.rdf_types,
+                graph=target_graph,
+            )

{maplib-0.14.5.dist-info → maplib-0.17.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: maplib
-Version: 0.14.5
+Version: 0.17.8
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -12,6 +12,8 @@ Classifier: Topic :: Database :: Database Engines/Servers
 Classifier: Topic :: Scientific/Engineering
 Requires-Dist: polars >=0.20.13
 Requires-Dist: pyarrow >=7.0.0
+Requires-Dist: fastapi[standard] >=0.115 ; extra == 'explorer'
+Provides-Extra: explorer
 License-File: LICENSE
 Summary: Dataframe-based interactive knowledge graph construction
 Keywords: rdf,graph,dataframe,sparql,ottr
@@ -33,13 +35,13 @@ Template expansion is typically zero-copy and nearly instantaneous, and the buil
 maplib is written in Rust, it is built on [Apache Arrow](https://arrow.apache.org/) using [Pola.rs](https://www.pola.rs/) and uses libraries from [Oxigraph](https://github.com/oxigraph/oxigraph) for handling linked data as well as parsing SPARQL queries.
 
 ## Installing
-The package is published on [PyPi](https://pypi.org/project/maplib/) and the API documented [here](https://datatreehouse.github.io/maplib/maplib/maplib.html):
+The package is published on [PyPi](https://pypi.org/project/maplib/) and the API documented [here](https://datatreehouse.github.io/maplib/maplib.html):
 ```shell
 pip install maplib
 ```
 Please send us a message, e.g. on LinkedIn (search for Data Treehouse) or on our [webpage](https://www.data-treehouse.com/contact-8) if you want to try out SHACL.  
 
-## Mapping
+## Model
 We can easily map DataFrames to RDF-graphs using the Python library. Below is a reproduction of the example in the paper [1]. Assume that we have a DataFrame given by: 
 
 ```python
@@ -65,8 +67,8 @@ That is, our DataFrame is:
 
 Then we can define a OTTR template, and create our knowledge graph by expanding this template with our DataFrame as input:
 ```python
-from maplib import Mapping, Prefix, Template, Argument, Parameter, Variable, RDFType, Triple, a
-pi = Prefix("pi", pi)
+from maplib import Model, Prefix, Template, Argument, Parameter, Variable, RDFType, Triple, a
+pi = Prefix(pi)
 
 p_var = Variable("p")
 c_var = Variable("c")
@@ -90,8 +92,8 @@ template = Template(
     ]
 )
 
-m = Mapping()
-m.expand(template, df)
+m = Model()
+m.map(template, df)
 hpizzas = """
     PREFIX pi:<https://github.com/DataTreehouse/maplib/pizza#>
     CONSTRUCT { ?p a pi:HeterodoxPizza } 
@@ -146,7 +148,7 @@ The resulting triples are given below:
 | str                            | str                                  | str                                   |
 | "<https://.../pizza#Hawaiian>" | "<http://.../22-rdf-syntax-ns#type>" | "<https://.../pizza#UnorthodoxPizza>" |
 
-If we are happy with the output of this construct-query, we can insert it in the mapping state. Afterwards we check that the triple is added with a query.
+If we are happy with the output of this construct-query, we can insert it in the model state. Afterwards we check that the triple is added with a query.
 
 ```python
 m.insert(hpizzas)
@@ -167,20 +169,34 @@ Indeed, we have added the triple:
 | "<https://github.com/DataTreehouse/maplib/pizza#Hawaiian>" |
 
 ## API
-The [API](https://datatreehouse.github.io/maplib/maplib/maplib.html) is simple, and contains only one class and a few methods for:
+The [API](https://datatreehouse.github.io/maplib/maplib.html) is simple, and contains only one class and a few methods for:
 - expanding templates
 - querying with SPARQL
-- validating SHACL
+- validating with SHACL
 - importing triples (Turtle, RDF/XML, NTriples)
-- writing triples (NTriples)
-- creating a new Mapping object (sprout) based on queries over the current Mapping object.
+- writing triples (Turtle, RDF/XML, NTriples)
+- creating a new Model object (sprout) based on queries over the current Model object.
 
-The API is documented [HERE](https://datatreehouse.github.io/maplib/maplib/maplib.html)
+The API is documented [HERE](https://datatreehouse.github.io/maplib/maplib.html)
+
+## Roadmap of features and optimizations
+Spring 2025
+- Datalog reasoning support ✅
+- Reduced memory footprint ✅
+- Further SPARQL optimizations
+- JSON-LD support
+
+Fall 2025
+- SHACL rules support
+- Improved TTL serialization (prettier and faster)
++++
+
+Roadmap is subject to changes,particularly user and customer requests. 
 
 ## References
 There is an associated paper [1] with associated benchmarks showing superior performance and scalability that can be found [here](https://ieeexplore.ieee.org/document/10106242). OTTR is described in [2].
 
-[1] M. Bakken, "maplib: Interactive, literal RDF model mapping for industry," in IEEE Access, doi: 10.1109/ACCESS.2023.3269093.
+[1] M. Bakken, "maplib: Interactive, literal RDF model model for industry," in IEEE Access, doi: 10.1109/ACCESS.2023.3269093.
 
 [2] M. G. Skjæveland, D. P. Lupp, L. H. Karlsen, and J. W. Klüwer, “Ottr: Formal templates for pattern-based ontology engineering.” in WOP (Book),
 2021, pp. 349–377.

maplib-0.17.8.dist-info/RECORD

@@ -0,0 +1,10 @@
+maplib-0.17.8.dist-info/METADATA,sha256=TNHeKU1e66a_C37fU46zC_xdqiBjJvSWOaW218LkXsI,9310
+maplib-0.17.8.dist-info/WHEEL,sha256=lukeIsDTsE1YVI71QKxojI1jBuBmCbLW3hTRwIrKSOQ,94
+maplib-0.17.8.dist-info/licenses/LICENSE,sha256=8f_rikNX2RHmVhT1CFq1M2itL6kTpawNjNTHUFCB870,11661
+maplib/.gitignore,sha256=88KgwL2QsVFk7EKzNn65u6Z-5ibwf9RPU6J68KuZotY,6
+maplib/adding_triples.py,sha256=5SklWdJaCFAUE22l_Na1jLPx2KKO0oirf3nVAF4sFnI,1092
+maplib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maplib/__init__.py,sha256=UlMsxGkMj9pMbN_zEeKdTGBGy2bEU-avX1gvd59Z_N0,1443
+maplib/__init__.pyi,sha256=ys2HScdIO4KO7o4nDfKgDE6CVylnf8WHgvVyO36Wwq8,29685
+maplib/maplib.cp39-win_amd64.pyd,sha256=qonrguGroEnkXToXQtCLAXKBzZKx_qRx-sCvtHxhe4k,92394496
+maplib-0.17.8.dist-info/RECORD,,

maplib/add_triples.py

@@ -1,21 +0,0 @@
-from maplib import Mapping, Template, IRI, Triple, Variable
-
-
-def add_triples(source: Mapping, target: Mapping, source_graph: str = None, target_graph: str = None):
-    for p in source.get_predicate_iris(source_graph):
-        subject = Variable("subject")
-        object = Variable("object")
-        template = Template(
-            iri=IRI("urn:maplib:tmp"),
-            parameters=[subject, object],
-            instances=[Triple(subject, p, object)]
-        )
-        sms = source.get_predicate(p, source_graph)
-        for sm in sms:
-            target.expand(
-                template,
-                sm.mappings,
-                unique_subset=["subject", "object"],
-                types=sm.rdf_types,
-                graph=target_graph
-            )

maplib-0.14.5.dist-info/RECORD

@@ -1,10 +0,0 @@
-maplib-0.14.5.dist-info/METADATA,sha256=4-xyP3XBQZF_swfo2GEEqZLY2sJ6LbM7PZ5TtBA98Xk,8903
-maplib-0.14.5.dist-info/WHEEL,sha256=lukeIsDTsE1YVI71QKxojI1jBuBmCbLW3hTRwIrKSOQ,94
-maplib-0.14.5.dist-info/licenses/LICENSE,sha256=8f_rikNX2RHmVhT1CFq1M2itL6kTpawNjNTHUFCB870,11661
-maplib/.gitignore,sha256=88KgwL2QsVFk7EKzNn65u6Z-5ibwf9RPU6J68KuZotY,6
-maplib/add_triples.py,sha256=HrDGnAaRoEvbU6ZqaI2qulPY-ABksqHwWAYKrM4k5Qo,780
-maplib/maplib.pyi,sha256=lZM8PzGzA9cT2IIevBZtbVZoj12lH2gvA2XW0KCtS9g,25191
-maplib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maplib/__init__.py,sha256=heYCc1Px-RP_VhclBENh3HWMrgibPd2_ZAuSPmItHII,218
-maplib/maplib.cp39-win_amd64.pyd,sha256=7NWRWC5nV2DwLKP9D819YJQxujC50h9O7B08vqHUfxc,73763328
-maplib-0.14.5.dist-info/RECORD,,