Source code

Download source archive ↓

src/rdflib/container.py

1import warnings
2from random import randint
3
4from rdflib.namespace import RDF
5from rdflib.term import BNode, URIRef
6
7__all__ = ["Container", "Bag", "Seq", "Alt", "NoElementException"]
8
9
10class Container:
11    """A class for constructing RDF containers, as per <https://www.w3.org/TR/rdf11-mt/#rdf-containers>
12
13    Basic usage, creating a `Bag` and adding to it:
14
15    ```python
16    >>> from rdflib import Graph, BNode, Literal, Bag
17    >>> g = Graph()
18    >>> b = Bag(g, BNode(), [Literal("One"), Literal("Two"), Literal("Three")])
19    >>> print(g.serialize(format="turtle"))
20    @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
21    <BLANKLINE>
22    [] a rdf:Bag ;
23        rdf:_1 "One" ;
24        rdf:_2 "Two" ;
25        rdf:_3 "Three" .
26    <BLANKLINE>
27    <BLANKLINE>
28
29    >>> # print out an item using an index reference
30    >>> print(b[2])
31    Two
32
33    >>> # add a new item
34    >>> b.append(Literal("Hello")) # doctest: +ELLIPSIS
35    <rdflib.container.Bag object at ...>
36    >>> print(g.serialize(format="turtle"))
37    @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
38    <BLANKLINE>
39    [] a rdf:Bag ;
40        rdf:_1 "One" ;
41        rdf:_2 "Two" ;
42        rdf:_3 "Three" ;
43        rdf:_4 "Hello" .
44    <BLANKLINE>
45    <BLANKLINE>
46
47    ```
48    """
49
50    def __init__(self, graph, uri, seq=[], rtype="Bag"):
51        """Creates a Container
52
53        Args:
54            graph: a Graph instance
55            uri: URI or Blank Node of the Container
56            seq: the elements of the Container
57            rtype: the type of Container, one of "Bag", "Seq" or "Alt"
58        """
59
60        self.graph = graph
61        self.uri = uri or BNode()
62        self._len = 0
63        self._rtype = rtype  # rdf:Bag or rdf:Seq or rdf:Alt
64
65        self.append_multiple(seq)
66
67        # adding triple corresponding to container type
68        self.graph.add((self.uri, RDF.type, RDF[self._rtype]))
69
70    def n3(self):
71        items = []
72        for i in range(len(self)):
73            v = self[i + 1]
74            items.append(v)
75
76        return "( %s )" % " ".join([a.n3() for a in items])
77
78    def _get_container(self):
79        """Returns the URI of the container"""
80
81        return self.uri
82
83    def __len__(self):
84        """Number of items in container"""
85
86        return self._len
87
88    def type_of_conatiner(self):
89        warnings.warn(
90            "rdflib.container.Container.type_of_conatiner is deprecated. "
91            "Use type_of_container method instead.",
92            DeprecationWarning,
93            stacklevel=2,
94        )
95        return self._rtype
96
97    def type_of_container(self):
98        return self._rtype
99
100    def index(self, item):
101        """Returns the 1-based numerical index of the item in the container"""
102
103        pred = self.graph.predicates(self.uri, item)
104        if not pred:
105            raise ValueError("%s is not in %s" % (item, "container"))
106        li_index = URIRef(str(RDF) + "_")
107
108        i = None
109        for p in pred:
110            i = int(p.replace(li_index, ""))
111        return i
112
113    def __getitem__(self, key):
114        """Returns item of the container at index key"""
115
116        c = self._get_container()
117
118        assert isinstance(key, int)
119        elem_uri = str(RDF) + "_" + str(key)
120        if key <= 0 or key > len(self):
121            raise KeyError(key)
122        v = self.graph.value(c, URIRef(elem_uri))
123        if v:
124            return v
125        else:
126            raise KeyError(key)
127
128    def __setitem__(self, key, value):
129        """Sets the item at index key or predicate rdf:_key of the container to value"""
130
131        assert isinstance(key, int)
132
133        c = self._get_container()
134        elem_uri = str(RDF) + "_" + str(key)
135        if key <= 0 or key > len(self):
136            raise KeyError(key)
137
138        self.graph.set((c, URIRef(elem_uri), value))
139
140    def __delitem__(self, key):
141        """Removing the item with index key or predicate rdf:_key"""
142
143        assert isinstance(key, int)
144        if key <= 0 or key > len(self):
145            raise KeyError(key)
146
147        graph = self.graph
148        container = self.uri
149        elem_uri = str(RDF) + "_" + str(key)
150        graph.remove((container, URIRef(elem_uri), None))
151        for j in range(key + 1, len(self) + 1):
152            elem_uri = str(RDF) + "_" + str(j)
153            v = graph.value(container, URIRef(elem_uri))
154            graph.remove((container, URIRef(elem_uri), v))
155            elem_uri = str(RDF) + "_" + str(j - 1)
156            graph.add((container, URIRef(elem_uri), v))
157
158        self._len -= 1
159
160    def items(self):
161        """Returns a list of all items in the container"""
162
163        l_ = []
164        container = self.uri
165        i = 1
166        while True:
167            elem_uri = str(RDF) + "_" + str(i)
168
169            if (container, URIRef(elem_uri), None) in self.graph:
170                i += 1
171                l_.append(self.graph.value(container, URIRef(elem_uri)))
172            else:
173                break
174        return l_
175
176    def end(self):  #
177        # find end index (1-based) of container
178
179        container = self.uri
180        i = 1
181        while True:
182            elem_uri = str(RDF) + "_" + str(i)
183
184            if (container, URIRef(elem_uri), None) in self.graph:
185                i += 1
186            else:
187                return i - 1
188
189    def append(self, item):
190        """Adding item to the end of the container"""
191
192        end = self.end()
193        elem_uri = str(RDF) + "_" + str(end + 1)
194        container = self.uri
195        self.graph.add((container, URIRef(elem_uri), item))
196        self._len += 1
197
198        return self
199
200    def append_multiple(self, other):
201        """Adding multiple elements to the container to the end which are in python list other"""
202
203        end = self.end()  # it should return the last index
204
205        container = self.uri
206        for item in other:
207            end += 1
208            self._len += 1
209            elem_uri = str(RDF) + "_" + str(end)
210            self.graph.add((container, URIRef(elem_uri), item))
211
212        return self
213
214    def clear(self):
215        """Removing all elements from the container"""
216
217        container = self.uri
218        graph = self.graph
219        i = 1
220        while True:
221            elem_uri = str(RDF) + "_" + str(i)
222            if (container, URIRef(elem_uri), None) in self.graph:
223                graph.remove((container, URIRef(elem_uri), None))
224                i += 1
225            else:
226                break
227        self._len = 0
228        return self
229
230
231class Bag(Container):
232    """Unordered container (no preference order of elements)"""
233
234    def __init__(self, graph, uri, seq=[]):
235        Container.__init__(self, graph, uri, seq, "Bag")
236
237
238class Alt(Container):
239    def __init__(self, graph, uri, seq=[]):
240        Container.__init__(self, graph, uri, seq, "Alt")
241
242    def anyone(self):
243        if len(self) == 0:
244            raise NoElementException()
245        else:
246            p = randint(1, len(self))
247            item = self.__getitem__(p)
248            return item
249
250
251class Seq(Container):
252    def __init__(self, graph, uri, seq=[]):
253        Container.__init__(self, graph, uri, seq, "Seq")
254
255    def add_at_position(self, pos, item):
256        assert isinstance(pos, int)
257        if pos <= 0 or pos > len(self) + 1:
258            raise ValueError("Invalid Position for inserting element in rdf:Seq")
259
260        if pos == len(self) + 1:
261            self.append(item)
262        else:
263            for j in range(len(self), pos - 1, -1):
264                container = self._get_container()
265                elem_uri = str(RDF) + "_" + str(j)
266                v = self.graph.value(container, URIRef(elem_uri))
267                self.graph.remove((container, URIRef(elem_uri), v))
268                elem_uri = str(RDF) + "_" + str(j + 1)
269                self.graph.add((container, URIRef(elem_uri), v))
270            elem_uri_pos = str(RDF) + "_" + str(pos)
271            self.graph.add((container, URIRef(elem_uri_pos), item))
272            self._len += 1
273        return self
274
275
276class NoElementException(Exception):  # noqa: N818
277    def __init__(self, message="rdf:Alt Container is empty"):
278        self.message = message
279
280    def __str__(self):
281        return self.message