maplib

64def explore(*args, **kwargs):
65    """Deprecated way to start an explore session.
66Use the explore method on a Model object instead
67"""
68    logger.warn("Calling `maplib.explore` is deprecated, use `m.explore()` on a `Model` object instead")
69    if kwargs.get("popup") == None or kwargs.get("popup") == True:
70        logger.warn("""Calling explore without a popup argument defaults to it being on.
71The popup argument is deprecated, so if you are relying on explore() opening a browser window
72please change this to something like
73
74```
75import webbrowser
76from maplib import Model
77
78m = Model()
79...
80s = m.explore()
81webbrowser.open(s.url, new=2)
82```
83""")
84        kwargs["popup"] = True
85    elif kwargs.get("popup") == False:
86        logger.warn("The new explore function on a Model, no longer defaults to popping up the browser ")
87
88
89    return _explore(*args, **kwargs)

 5def add_triples(
 6    source: Model, target: Model, source_graph: str = None, target_graph: str = None
 7):
 8    """(Zero) copy the triples from one Model into another.
 9
10    :param source: The source model
11    :param target: The target model
12    :param source_graph: The named graph in the source model to copy from. None means default graph.
13    :param target_graph: The named graph in the target model to copy into. None means default graph.
14    """
15    for p in source.get_predicate_iris(source_graph):
16        subject = Variable("subject")
17        object = Variable("object")
18        template = Template(
19            iri=IRI("urn:maplib:tmp"),
20            parameters=[subject, object],
21            instances=[Triple(subject, p, object)],
22        )
23        sms = source.get_predicate(p, source_graph)
24        for sm in sms:
25            target.map(
26                template,
27                sm.mappings,
28                types=sm.rdf_types,
29                graph=target_graph,
30            )

 9def generate_templates(m: Model, graph: Optional[str]) -> Dict[str, Template]:
10    """Generate templates for instantiating the classes in an ontology
11
12    :param m: The model where the ontology is stored. We mainly rely on rdfs:subClassOf, rdfs:range and rdfs:domain.
13    :param graph: The named graph where the ontology is stored.
14
15    :return A dictionary of templates for instantiating the classes in the ontology, where the keys are the class URIs.
16
17    Usage example - note that it is important to add the templates to the Model you want to populate.
18    >>> from maplib import Model, create_templates
19    >>>
20    >>> m_ont = Model()
21    >>> m_ont.read("my_ontology.ttl")
22    >>> templates = generate_templates(m_ont)
23    >>> m = Model()
24    >>> for t in templates.values():
25    >>>     m.add_template(t)
26    >>> m.map("https://example.net/MyClass", df)
27    """
28
29    properties = get_properties(m, graph=graph)
30    properties_by_domain = {}
31    properties_by_range = {}
32    for r in properties.iter_rows(named=True):
33        dom = r["domain"]
34        if dom in properties_by_domain:
35            properties_by_domain[dom].append(r)
36        else:
37            properties_by_domain[dom] = [r]
38
39        ran = r["range"]
40        if ran in properties_by_range:
41            properties_by_range[ran].append(r)
42        else:
43            properties_by_range[ran] = [r]
44
45    subclasses = get_subclasses(m, graph=graph)
46
47    subclass_of = {}
48    for r in (
49        subclasses.group_by("child")
50        .agg(pl.col("parent").alias("parents"))
51        .iter_rows(named=True)
52    ):
53        subclass_of[r["child"]] = r["parents"]
54
55    class_ordering = topological_sort(subclasses)
56
57    templates_without_typing = generate_templates_without_typing(
58        properties_by_domain, properties_by_range, class_ordering, subclass_of
59    )
60    templates_with_typing = generate_templates_with_typing(templates_without_typing)
61    templates = {}
62    for t, template in templates_without_typing.items():
63
64        templates[t + "_notype"] = template
65    for t, template in templates_with_typing.items():
66        templates[t] = template
67
68    return templates