pyjelly 0.1.0__py3-none-any.whl

pyjelly/integrations/rdflib/parse.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+from collections.abc import Generator, Iterable
+from typing import IO, Any
+from typing_extensions import Never, override
+
+import rdflib
+from rdflib.graph import DATASET_DEFAULT_GRAPH_ID, Dataset, Graph
+from rdflib.parser import InputSource
+from rdflib.parser import Parser as RDFLibParser
+from rdflib.store import Store
+
+from pyjelly import jelly
+from pyjelly.errors import JellyConformanceError
+from pyjelly.options import StreamOptions
+from pyjelly.parse.decode import Adapter, Decoder
+from pyjelly.parse.ioutils import get_options_and_frames
+
+
+class RDFLibAdapter(Adapter):
+    @override
+    def iri(self, iri: str) -> rdflib.URIRef:
+        return rdflib.URIRef(iri)
+
+    @override
+    def bnode(self, bnode: str) -> rdflib.BNode:
+        return rdflib.BNode(bnode)
+
+    @override
+    def default_graph(self) -> rdflib.URIRef:
+        return DATASET_DEFAULT_GRAPH_ID
+
+    @override
+    def literal(
+        self,
+        lex: str,
+        language: str | None = None,
+        datatype: str | None = None,
+    ) -> rdflib.Literal:
+        return rdflib.Literal(lex, lang=language, datatype=datatype)
+
+
+def _adapter_missing(feature: str, *, options: StreamOptions) -> Never:
+    physical_type_name = jelly.PhysicalStreamType.Name(
+        options.stream_types.physical_type
+    )
+    logical_type_name = jelly.LogicalStreamType.Name(options.stream_types.logical_type)
+    msg = (
+        f"adapter with {physical_type_name} and {logical_type_name} "
+        f"does not implement {feature}"
+    )
+    raise NotImplementedError(msg)
+
+
+class RDFLibTriplesAdapter(RDFLibAdapter):
+    graph: Graph
+
+    def __init__(self, graph: Graph, options: StreamOptions) -> None:
+        super().__init__(options=options)
+        self.graph = graph
+
+    @override
+    def triple(self, terms: Iterable[Any]) -> Any:
+        self.graph.add(terms)  # type: ignore[arg-type]
+
+    @override
+    def namespace_declaration(self, name: str, iri: str) -> None:
+        self.graph.bind(name, self.iri(iri))
+
+    def frame(self) -> Graph | None:
+        if self.options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_GRAPHS:
+            this_graph = self.graph
+            self.graph = Graph(store=self.graph.store)
+            return this_graph
+        if self.options.stream_types.logical_type in (
+            jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED,
+            jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES,
+        ):
+            return None
+        return _adapter_missing("interpreting frames", options=self.options)
+
+
+class RDFLibQuadsBaseAdapter(RDFLibAdapter):
+    def __init__(self, dataset: Dataset, options: StreamOptions) -> None:
+        super().__init__(options=options)
+        self.dataset = dataset
+
+    @override
+    def frame(self) -> Dataset | None:
+        if self.options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_DATASETS:
+            this_dataset = self.dataset
+            self.dataset = Dataset(store=self.dataset.store)
+            return this_dataset
+        if self.options.stream_types.logical_type in (
+            jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED,
+            jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS,
+        ):
+            return None
+        return _adapter_missing("interpreting frames", options=self.options)
+
+
+class RDFLibQuadsAdapter(RDFLibQuadsBaseAdapter):
+    @override
+    def namespace_declaration(self, name: str, iri: str) -> None:
+        self.dataset.bind(name, self.iri(iri))
+
+    @override
+    def quad(self, terms: Iterable[Any]) -> Any:
+        self.dataset.add(terms)  # type: ignore[arg-type]
+
+
+class RDFLibGraphsAdapter(RDFLibQuadsBaseAdapter):
+    _graph: Graph | None = None
+
+    def __init__(self, dataset: Dataset, options: StreamOptions) -> None:
+        super().__init__(dataset=dataset, options=options)
+        self._graph = None
+
+    @property
+    def graph(self) -> Graph:
+        if self._graph is None:
+            msg = "new graph was not started"
+            raise JellyConformanceError(msg)
+        return self._graph
+
+    @override
+    def graph_start(self, graph_id: str) -> None:
+        self._graph = Graph(store=self.dataset.store, identifier=graph_id)
+
+    @override
+    def namespace_declaration(self, name: str, iri: str) -> None:
+        self.graph.bind(name, self.iri(iri))
+
+    @override
+    def triple(self, terms: Iterable[Any]) -> None:
+        self.graph.add(terms)  # type: ignore[arg-type]
+
+    @override
+    def graph_end(self) -> None:
+        self.dataset.store.add_graph(self.graph)
+        self._graph = None
+
+    def frame(self) -> Dataset | None:
+        if self.options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_DATASETS:
+            this_dataset = self.dataset
+            self._graph = None
+            self.dataset = Dataset(store=self.dataset.store)
+            return this_dataset
+        return super().frame()
+
+
+def parse_flat_stream(
+    frames: Iterable[jelly.RdfStreamFrame],
+    sink: Graph,
+    options: StreamOptions,
+) -> Dataset | Graph:
+    assert options.stream_types.flat
+    ds = None
+
+    adapter: Adapter
+    if options.stream_types.physical_type == jelly.PHYSICAL_STREAM_TYPE_TRIPLES:
+        adapter = RDFLibTriplesAdapter(graph=sink, options=options)
+    else:
+        ds = Dataset(store=sink.store, default_union=True)
+        ds.default_context = sink
+
+        if options.stream_types.physical_type == jelly.PHYSICAL_STREAM_TYPE_QUADS:
+            adapter = RDFLibQuadsAdapter(dataset=ds, options=options)
+
+        else:  # jelly.PHYSICAL_STREAM_TYPE_GRAPHS
+            adapter = RDFLibGraphsAdapter(dataset=ds, options=options)
+    decoder = Decoder(adapter=adapter)
+    for frame in frames:
+        decoder.decode_frame(frame=frame)
+    return ds or sink
+
+
+def parse_grouped_graph_stream(
+    frames: Iterable[jelly.RdfStreamFrame],
+    sink: Graph,
+    options: StreamOptions,
+) -> Dataset:
+    adapter = RDFLibTriplesAdapter(graph=sink, options=options)
+    ds = Dataset(store=sink.store, default_union=True)
+    ds.default_context = sink
+    decoder = Decoder(adapter=adapter)
+    for frame in frames:
+        graph = decoder.decode_frame(frame=frame)
+        ds.add_graph(graph)
+    return ds
+
+
+def parse_grouped_dataset_stream(
+    frames: Iterable[jelly.RdfStreamFrame],
+    options: StreamOptions,
+    store: Store | str = "default",
+) -> Generator[Dataset]:
+    adapter = RDFLibGraphsAdapter(dataset=Dataset(store=store), options=options)
+    decoder = Decoder(adapter=adapter)
+    for frame in frames:
+        yield decoder.decode_frame(frame=frame)
+
+
+def graph_or_dataset_from_jelly(
+    inp: IO[bytes],
+    sink: Graph,
+) -> Dataset | Graph:
+    options, frames = get_options_and_frames(inp)
+
+    if options.stream_types.flat:
+        return parse_flat_stream(frames=frames, sink=sink, options=options)
+
+    if options.stream_types.physical_type == jelly.PHYSICAL_STREAM_TYPE_TRIPLES:
+        return parse_grouped_graph_stream(frames=frames, sink=sink, options=options)
+
+    msg = (
+        "the stream contains multiple datasets and cannot be parsed into "
+        "a single dataset"
+    )
+    raise NotImplementedError(msg)
+
+
+class RDFLibJellyParser(RDFLibParser):
+    def parse(
+        self,
+        source: InputSource,
+        sink: Graph,
+    ) -> None:
+        inp = source.getByteStream()  # type: ignore[no-untyped-call]
+        if inp is None:
+            msg = "expected source to be a stream of bytes"
+            raise TypeError(msg)
+        graph_or_dataset_from_jelly(inp, sink=sink)

pyjelly/integrations/rdflib/serialize.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from functools import singledispatch
+from typing import IO, Any
+from typing_extensions import override
+
+import rdflib
+from rdflib.graph import DATASET_DEFAULT_GRAPH_ID, Dataset, Graph, QuotedGraph
+from rdflib.serializer import Serializer as RDFLibSerializer
+
+from pyjelly import jelly
+from pyjelly.serialize.encode import RowsAndTerm, Slot, TermEncoder
+from pyjelly.serialize.ioutils import write_delimited, write_single
+from pyjelly.serialize.streams import GraphStream, QuadStream, Stream, TripleStream
+
+
+class RDFLibTermEncoder(TermEncoder):
+    def encode_any(self, term: object, slot: Slot) -> RowsAndTerm:
+        if slot is Slot.graph and term == DATASET_DEFAULT_GRAPH_ID:
+            return self.encode_default_graph()
+
+        if isinstance(term, rdflib.URIRef):
+            return self.encode_iri(term)
+
+        if isinstance(term, rdflib.Literal):
+            return self.encode_literal(
+                lex=str(term),
+                language=term.language,
+                # `datatype` is cast to `str` explicitly because
+                # `URIRef.__eq__` overrides `str.__eq__` in an incompatible manner
+                datatype=term.datatype and str(term.datatype),
+            )
+
+        if isinstance(term, rdflib.BNode):
+            return self.encode_bnode(str(term))
+
+        return super().encode_any(term, slot)  # error if not handled
+
+
+def namespace_declarations(store: Graph, stream: Stream) -> None:
+    for prefix, namespace in store.namespaces():
+        stream.namespace_declaration(name=prefix, iri=namespace)
+
+
+@singledispatch
+def stream_frames(stream: Stream, data: Graph) -> Generator[jelly.RdfStreamFrame]:  # noqa: ARG001
+    msg = f"invalid stream implementation {stream}"
+    raise TypeError(msg)
+
+
+@stream_frames.register
+def triples_stream(
+    stream: TripleStream,
+    data: Graph,
+) -> Generator[jelly.RdfStreamFrame]:
+    assert not isinstance(data, Dataset)
+    stream.enroll()
+    if stream.options.namespace_declarations:
+        namespace_declarations(data, stream)
+    for terms in data:
+        if frame := stream.triple(terms):
+            yield frame
+    if frame := stream.flow.to_stream_frame():
+        yield frame
+
+
+@stream_frames.register
+def quads_stream(stream: QuadStream, data: Graph) -> Generator[jelly.RdfStreamFrame]:
+    assert isinstance(data, Dataset)
+    stream.enroll()
+    if stream.options.namespace_declarations:
+        namespace_declarations(data, stream)
+    for terms in data.quads():
+        if frame := stream.quad(terms):
+            yield frame
+    if frame := stream.flow.to_stream_frame():
+        yield frame
+
+
+@stream_frames.register
+def graphs_stream(stream: GraphStream, data: Graph) -> Generator[jelly.RdfStreamFrame]:
+    assert isinstance(data, Dataset)
+    stream.enroll()
+    if stream.options.namespace_declarations:
+        namespace_declarations(data, stream)
+    for graph in data.graphs():
+        yield from stream.graph(graph_id=graph.identifier, graph=graph)
+    if frame := stream.flow.to_stream_frame():
+        yield frame
+
+
+class RDFLibJellySerializer(RDFLibSerializer):
+    """
+    RDFLib serializer for writing graphs in Jelly RDF stream format.
+
+    Handles streaming RDF terms into Jelly frames using internal encoders.
+    Supports only graphs and datasets (not quoted graphs).
+
+    """
+
+    def __init__(self, store: Graph) -> None:
+        if isinstance(store, QuotedGraph):
+            msg = "N3 format is not supported"
+            raise NotImplementedError(msg)
+        super().__init__(store)
+
+    @override
+    def serialize(  # type: ignore[override]
+        self,
+        out: IO[bytes],
+        /,
+        *,
+        stream: Stream,
+        **unused: Any,
+    ) -> None:
+        write = write_delimited if stream.options.delimited else write_single
+        for stream_frame in stream_frames(stream, self.store):
+            write(stream_frame, out)

pyjelly/jelly/__init__.py

@@ -0,0 +1,5 @@
+from pyjelly.jelly import rdf_pb2
+from pyjelly.jelly.rdf_pb2 import *
+
+# workaround for mypyc
+globals().update(vars(rdf_pb2))

pyjelly/jelly/rdf_pb2.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: rdf.proto
+# Protobuf Python Version: 5.29.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    0,
+    '',
+    'rdf.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\trdf.proto\x12!eu.ostrzyciel.jelly.core.proto.v1\",\n\x06RdfIri\x12\x11\n\tprefix_id\x18\x01 \x01(\r\x12\x0f\n\x07name_id\x18\x02 \x01(\r\"O\n\nRdfLiteral\x12\x0b\n\x03lex\x18\x01 \x01(\t\x12\x11\n\x07langtag\x18\x02 \x01(\tH\x00\x12\x12\n\x08\x64\x61tatype\x18\x03 \x01(\rH\x00\x42\r\n\x0bliteralKind\"\x11\n\x0fRdfDefaultGraph\"\xbb\x05\n\tRdfTriple\x12:\n\x05s_iri\x18\x01 \x01(\x0b\x32).eu.ostrzyciel.jelly.core.proto.v1.RdfIriH\x00\x12\x11\n\x07s_bnode\x18\x02 \x01(\tH\x00\x12\x42\n\ts_literal\x18\x03 \x01(\x0b\x32-.eu.ostrzyciel.jelly.core.proto.v1.RdfLiteralH\x00\x12\x45\n\rs_triple_term\x18\x04 \x01(\x0b\x32,.eu.ostrzyciel.jelly.core.proto.v1.RdfTripleH\x00\x12:\n\x05p_iri\x18\x05 \x01(\x0b\x32).eu.ostrzyciel.jelly.core.proto.v1.RdfIriH\x01\x12\x11\n\x07p_bnode\x18\x06 \x01(\tH\x01\x12\x42\n\tp_literal\x18\x07 \x01(\x0b\x32-.eu.ostrzyciel.jelly.core.proto.v1.RdfLiteralH\x01\x12\x45\n\rp_triple_term\x18\x08 \x01(\x0b\x32,.eu.ostrzyciel.jelly.core.proto.v1.RdfTripleH\x01\x12:\n\x05o_iri\x18\t \x01(\x0b\x32).eu.ostrzyciel.jelly.core.proto.v1.RdfIriH\x02\x12\x11\n\x07o_bnode\x18\n \x01(\tH\x02\x12\x42\n\to_literal\x18\x0b \x01(\x0b\x32-.eu.ostrzyciel.jelly.core.proto.v1.RdfLiteralH\x02\x12\x45\n\ro_triple_term\x18\x0c \x01(\x0b\x32,.eu.ostrzyciel.jelly.core.proto.v1.RdfTripleH\x02\x42\t\n\x07subjectB\x0b\n\tpredicateB\x08\n\x06object\"\xa4\x07\n\x07RdfQuad\x12:\n\x05s_iri\x18\x01 \x01(\x0b\x32).eu.ostrzyciel.jelly.core.proto.v1.RdfIriH\x00\x12\x11\n\x07s_bnode\x18\x02 \x01(\tH\x00\x12\x42\n\ts_literal\x18\x03 \x01(\x0b\x32-.eu.ostrzyciel.jelly.core.proto.v1.RdfLiteralH\x00\x12\x45\n\rs_triple_term\x18\x04 \x01(\x0b\x32,.eu.ostrzyciel.jelly.core.proto.v1.RdfTripleH\x00\x12:\n\x05p_iri\x18\x05 \x01(\x0b\x32).eu.ostrzyciel.jelly.core.proto.v1.RdfIriH\x01\x12\x11\n\x07p_bnode\x18\x06 \x01(\tH\x01\x12\x42\n\tp_literal\x18\x07 \x01(\x0b\x32-.eu.ostrzyciel.jelly.core.proto.v1.RdfLiteralH\x01\x12\x45\n\rp_triple_term\x18\x08 \x01(\x0b\x32,.eu.ostrzyciel.jelly.core.proto.v1.RdfTripleH\x01\x12:\n\x05o_iri\x18\t \x01(\x0b\x32).eu.ostrzyciel.jelly.core.proto.v1.RdfIriH\x02\x12\x11\n\x07o_bnode\x18\n \x01(\tH\x02\x12\x42\n\to_literal\x18\x0b \x01(\x0b\x32-.eu.ostrzyciel.jelly.core.proto.v1.RdfLiteralH\x02\x12\x45\n\ro_triple_term\x18\x0c \x01(\x0b\x32,.eu.ostrzyciel.jelly.core.proto.v1.RdfTripleH\x02\x12:\n\x05g_iri\x18\r \x01(\x0b\x32).eu.ostrzyciel.jelly.core.proto.v1.RdfIriH\x03\x12\x11\n\x07g_bnode\x18\x0e \x01(\tH\x03\x12M\n\x0fg_default_graph\x18\x0f \x01(\x0b\x32\x32.eu.ostrzyciel.jelly.core.proto.v1.RdfDefaultGraphH\x03\x12\x42\n\tg_literal\x18\x10 \x01(\x0b\x32-.eu.ostrzyciel.jelly.core.proto.v1.RdfLiteralH\x03\x42\t\n\x07subjectB\x0b\n\tpredicateB\x08\n\x06objectB\x07\n\x05graph\"\xfa\x01\n\rRdfGraphStart\x12:\n\x05g_iri\x18\x01 \x01(\x0b\x32).eu.ostrzyciel.jelly.core.proto.v1.RdfIriH\x00\x12\x11\n\x07g_bnode\x18\x02 \x01(\tH\x00\x12M\n\x0fg_default_graph\x18\x03 \x01(\x0b\x32\x32.eu.ostrzyciel.jelly.core.proto.v1.RdfDefaultGraphH\x00\x12\x42\n\tg_literal\x18\x04 \x01(\x0b\x32-.eu.ostrzyciel.jelly.core.proto.v1.RdfLiteralH\x00\x42\x07\n\x05graph\"\r\n\x0bRdfGraphEnd\"a\n\x17RdfNamespaceDeclaration\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x38\n\x05value\x18\x02 \x01(\x0b\x32).eu.ostrzyciel.jelly.core.proto.v1.RdfIri\")\n\x0cRdfNameEntry\x12\n\n\x02id\x18\x01 \x01(\r\x12\r\n\x05value\x18\x02 \x01(\t\"+\n\x0eRdfPrefixEntry\x12\n\n\x02id\x18\x01 \x01(\r\x12\r\n\x05value\x18\x02 \x01(\t\"-\n\x10RdfDatatypeEntry\x12\n\n\x02id\x18\x01 \x01(\r\x12\r\n\x05value\x18\x02 \x01(\t\"\xe1\x02\n\x10RdfStreamOptions\x12\x13\n\x0bstream_name\x18\x01 \x01(\t\x12L\n\rphysical_type\x18\x02 \x01(\x0e\x32\x35.eu.ostrzyciel.jelly.core.proto.v1.PhysicalStreamType\x12\x1e\n\x16generalized_statements\x18\x03 \x01(\x08\x12\x10\n\x08rdf_star\x18\x04 \x01(\x08\x12\x1b\n\x13max_name_table_size\x18\t \x01(\r\x12\x1d\n\x15max_prefix_table_size\x18\n \x01(\r\x12\x1f\n\x17max_datatype_table_size\x18\x0b \x01(\r\x12J\n\x0clogical_type\x18\x0e \x01(\x0e\x32\x34.eu.ostrzyciel.jelly.core.proto.v1.LogicalStreamType\x12\x0f\n\x07version\x18\x0f \x01(\r\"\x87\x05\n\x0cRdfStreamRow\x12\x46\n\x07options\x18\x01 \x01(\x0b\x32\x33.eu.ostrzyciel.jelly.core.proto.v1.RdfStreamOptionsH\x00\x12>\n\x06triple\x18\x02 \x01(\x0b\x32,.eu.ostrzyciel.jelly.core.proto.v1.RdfTripleH\x00\x12:\n\x04quad\x18\x03 \x01(\x0b\x32*.eu.ostrzyciel.jelly.core.proto.v1.RdfQuadH\x00\x12G\n\x0bgraph_start\x18\x04 \x01(\x0b\x32\x30.eu.ostrzyciel.jelly.core.proto.v1.RdfGraphStartH\x00\x12\x43\n\tgraph_end\x18\x05 \x01(\x0b\x32..eu.ostrzyciel.jelly.core.proto.v1.RdfGraphEndH\x00\x12O\n\tnamespace\x18\x06 \x01(\x0b\x32:.eu.ostrzyciel.jelly.core.proto.v1.RdfNamespaceDeclarationH\x00\x12?\n\x04name\x18\t \x01(\x0b\x32/.eu.ostrzyciel.jelly.core.proto.v1.RdfNameEntryH\x00\x12\x43\n\x06prefix\x18\n \x01(\x0b\x32\x31.eu.ostrzyciel.jelly.core.proto.v1.RdfPrefixEntryH\x00\x12G\n\x08\x64\x61tatype\x18\x0b \x01(\x0b\x32\x33.eu.ostrzyciel.jelly.core.proto.v1.RdfDatatypeEntryH\x00\x42\x05\n\x03row\"\xd3\x01\n\x0eRdfStreamFrame\x12=\n\x04rows\x18\x01 \x03(\x0b\x32/.eu.ostrzyciel.jelly.core.proto.v1.RdfStreamRow\x12Q\n\x08metadata\x18\x0f \x03(\x0b\x32?.eu.ostrzyciel.jelly.core.proto.v1.RdfStreamFrame.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01*\x9d\x01\n\x12PhysicalStreamType\x12$\n PHYSICAL_STREAM_TYPE_UNSPECIFIED\x10\x00\x12 \n\x1cPHYSICAL_STREAM_TYPE_TRIPLES\x10\x01\x12\x1e\n\x1aPHYSICAL_STREAM_TYPE_QUADS\x10\x02\x12\x1f\n\x1bPHYSICAL_STREAM_TYPE_GRAPHS\x10\x03*\xc4\x02\n\x11LogicalStreamType\x12#\n\x1fLOGICAL_STREAM_TYPE_UNSPECIFIED\x10\x00\x12$\n LOGICAL_STREAM_TYPE_FLAT_TRIPLES\x10\x01\x12\"\n\x1eLOGICAL_STREAM_TYPE_FLAT_QUADS\x10\x02\x12\x1e\n\x1aLOGICAL_STREAM_TYPE_GRAPHS\x10\x03\x12 \n\x1cLOGICAL_STREAM_TYPE_DATASETS\x10\x04\x12&\n\"LOGICAL_STREAM_TYPE_SUBJECT_GRAPHS\x10\r\x12$\n LOGICAL_STREAM_TYPE_NAMED_GRAPHS\x10\x0e\x12\x30\n,LOGICAL_STREAM_TYPE_TIMESTAMPED_NAMED_GRAPHS\x10rb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'rdf_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_RDFSTREAMFRAME_METADATAENTRY']._loaded_options = None
+  _globals['_RDFSTREAMFRAME_METADATAENTRY']._serialized_options = b'8\001'
+  _globals['_PHYSICALSTREAMTYPE']._serialized_start=3554
+  _globals['_PHYSICALSTREAMTYPE']._serialized_end=3711
+  _globals['_LOGICALSTREAMTYPE']._serialized_start=3714
+  _globals['_LOGICALSTREAMTYPE']._serialized_end=4038
+  _globals['_RDFIRI']._serialized_start=48
+  _globals['_RDFIRI']._serialized_end=92
+  _globals['_RDFLITERAL']._serialized_start=94
+  _globals['_RDFLITERAL']._serialized_end=173
+  _globals['_RDFDEFAULTGRAPH']._serialized_start=175
+  _globals['_RDFDEFAULTGRAPH']._serialized_end=192
+  _globals['_RDFTRIPLE']._serialized_start=195
+  _globals['_RDFTRIPLE']._serialized_end=894
+  _globals['_RDFQUAD']._serialized_start=897
+  _globals['_RDFQUAD']._serialized_end=1829
+  _globals['_RDFGRAPHSTART']._serialized_start=1832
+  _globals['_RDFGRAPHSTART']._serialized_end=2082
+  _globals['_RDFGRAPHEND']._serialized_start=2084
+  _globals['_RDFGRAPHEND']._serialized_end=2097
+  _globals['_RDFNAMESPACEDECLARATION']._serialized_start=2099
+  _globals['_RDFNAMESPACEDECLARATION']._serialized_end=2196
+  _globals['_RDFNAMEENTRY']._serialized_start=2198
+  _globals['_RDFNAMEENTRY']._serialized_end=2239
+  _globals['_RDFPREFIXENTRY']._serialized_start=2241
+  _globals['_RDFPREFIXENTRY']._serialized_end=2284
+  _globals['_RDFDATATYPEENTRY']._serialized_start=2286
+  _globals['_RDFDATATYPEENTRY']._serialized_end=2331
+  _globals['_RDFSTREAMOPTIONS']._serialized_start=2334
+  _globals['_RDFSTREAMOPTIONS']._serialized_end=2687
+  _globals['_RDFSTREAMROW']._serialized_start=2690
+  _globals['_RDFSTREAMROW']._serialized_end=3337
+  _globals['_RDFSTREAMFRAME']._serialized_start=3340
+  _globals['_RDFSTREAMFRAME']._serialized_end=3551
+  _globals['_RDFSTREAMFRAME_METADATAENTRY']._serialized_start=3504
+  _globals['_RDFSTREAMFRAME_METADATAENTRY']._serialized_end=3551
+# @@protoc_insertion_point(module_scope)

pyjelly/jelly/rdf_pb2.pyi

@@ -0,0 +1,230 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class PhysicalStreamType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    PHYSICAL_STREAM_TYPE_UNSPECIFIED: _ClassVar[PhysicalStreamType]
+    PHYSICAL_STREAM_TYPE_TRIPLES: _ClassVar[PhysicalStreamType]
+    PHYSICAL_STREAM_TYPE_QUADS: _ClassVar[PhysicalStreamType]
+    PHYSICAL_STREAM_TYPE_GRAPHS: _ClassVar[PhysicalStreamType]
+
+class LogicalStreamType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    LOGICAL_STREAM_TYPE_UNSPECIFIED: _ClassVar[LogicalStreamType]
+    LOGICAL_STREAM_TYPE_FLAT_TRIPLES: _ClassVar[LogicalStreamType]
+    LOGICAL_STREAM_TYPE_FLAT_QUADS: _ClassVar[LogicalStreamType]
+    LOGICAL_STREAM_TYPE_GRAPHS: _ClassVar[LogicalStreamType]
+    LOGICAL_STREAM_TYPE_DATASETS: _ClassVar[LogicalStreamType]
+    LOGICAL_STREAM_TYPE_SUBJECT_GRAPHS: _ClassVar[LogicalStreamType]
+    LOGICAL_STREAM_TYPE_NAMED_GRAPHS: _ClassVar[LogicalStreamType]
+    LOGICAL_STREAM_TYPE_TIMESTAMPED_NAMED_GRAPHS: _ClassVar[LogicalStreamType]
+PHYSICAL_STREAM_TYPE_UNSPECIFIED: PhysicalStreamType
+PHYSICAL_STREAM_TYPE_TRIPLES: PhysicalStreamType
+PHYSICAL_STREAM_TYPE_QUADS: PhysicalStreamType
+PHYSICAL_STREAM_TYPE_GRAPHS: PhysicalStreamType
+LOGICAL_STREAM_TYPE_UNSPECIFIED: LogicalStreamType
+LOGICAL_STREAM_TYPE_FLAT_TRIPLES: LogicalStreamType
+LOGICAL_STREAM_TYPE_FLAT_QUADS: LogicalStreamType
+LOGICAL_STREAM_TYPE_GRAPHS: LogicalStreamType
+LOGICAL_STREAM_TYPE_DATASETS: LogicalStreamType
+LOGICAL_STREAM_TYPE_SUBJECT_GRAPHS: LogicalStreamType
+LOGICAL_STREAM_TYPE_NAMED_GRAPHS: LogicalStreamType
+LOGICAL_STREAM_TYPE_TIMESTAMPED_NAMED_GRAPHS: LogicalStreamType
+
+class RdfIri(_message.Message):
+    __slots__ = ("prefix_id", "name_id")
+    PREFIX_ID_FIELD_NUMBER: _ClassVar[int]
+    NAME_ID_FIELD_NUMBER: _ClassVar[int]
+    prefix_id: int
+    name_id: int
+    def __init__(self, prefix_id: _Optional[int] = ..., name_id: _Optional[int] = ...) -> None: ...
+
+class RdfLiteral(_message.Message):
+    __slots__ = ("lex", "langtag", "datatype")
+    LEX_FIELD_NUMBER: _ClassVar[int]
+    LANGTAG_FIELD_NUMBER: _ClassVar[int]
+    DATATYPE_FIELD_NUMBER: _ClassVar[int]
+    lex: str
+    langtag: str
+    datatype: int
+    def __init__(self, lex: _Optional[str] = ..., langtag: _Optional[str] = ..., datatype: _Optional[int] = ...) -> None: ...
+
+class RdfDefaultGraph(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class RdfTriple(_message.Message):
+    __slots__ = ("s_iri", "s_bnode", "s_literal", "s_triple_term", "p_iri", "p_bnode", "p_literal", "p_triple_term", "o_iri", "o_bnode", "o_literal", "o_triple_term")
+    S_IRI_FIELD_NUMBER: _ClassVar[int]
+    S_BNODE_FIELD_NUMBER: _ClassVar[int]
+    S_LITERAL_FIELD_NUMBER: _ClassVar[int]
+    S_TRIPLE_TERM_FIELD_NUMBER: _ClassVar[int]
+    P_IRI_FIELD_NUMBER: _ClassVar[int]
+    P_BNODE_FIELD_NUMBER: _ClassVar[int]
+    P_LITERAL_FIELD_NUMBER: _ClassVar[int]
+    P_TRIPLE_TERM_FIELD_NUMBER: _ClassVar[int]
+    O_IRI_FIELD_NUMBER: _ClassVar[int]
+    O_BNODE_FIELD_NUMBER: _ClassVar[int]
+    O_LITERAL_FIELD_NUMBER: _ClassVar[int]
+    O_TRIPLE_TERM_FIELD_NUMBER: _ClassVar[int]
+    s_iri: RdfIri
+    s_bnode: str
+    s_literal: RdfLiteral
+    s_triple_term: RdfTriple
+    p_iri: RdfIri
+    p_bnode: str
+    p_literal: RdfLiteral
+    p_triple_term: RdfTriple
+    o_iri: RdfIri
+    o_bnode: str
+    o_literal: RdfLiteral
+    o_triple_term: RdfTriple
+    def __init__(self, s_iri: _Optional[_Union[RdfIri, _Mapping]] = ..., s_bnode: _Optional[str] = ..., s_literal: _Optional[_Union[RdfLiteral, _Mapping]] = ..., s_triple_term: _Optional[_Union[RdfTriple, _Mapping]] = ..., p_iri: _Optional[_Union[RdfIri, _Mapping]] = ..., p_bnode: _Optional[str] = ..., p_literal: _Optional[_Union[RdfLiteral, _Mapping]] = ..., p_triple_term: _Optional[_Union[RdfTriple, _Mapping]] = ..., o_iri: _Optional[_Union[RdfIri, _Mapping]] = ..., o_bnode: _Optional[str] = ..., o_literal: _Optional[_Union[RdfLiteral, _Mapping]] = ..., o_triple_term: _Optional[_Union[RdfTriple, _Mapping]] = ...) -> None: ...
+
+class RdfQuad(_message.Message):
+    __slots__ = ("s_iri", "s_bnode", "s_literal", "s_triple_term", "p_iri", "p_bnode", "p_literal", "p_triple_term", "o_iri", "o_bnode", "o_literal", "o_triple_term", "g_iri", "g_bnode", "g_default_graph", "g_literal")
+    S_IRI_FIELD_NUMBER: _ClassVar[int]
+    S_BNODE_FIELD_NUMBER: _ClassVar[int]
+    S_LITERAL_FIELD_NUMBER: _ClassVar[int]
+    S_TRIPLE_TERM_FIELD_NUMBER: _ClassVar[int]
+    P_IRI_FIELD_NUMBER: _ClassVar[int]
+    P_BNODE_FIELD_NUMBER: _ClassVar[int]
+    P_LITERAL_FIELD_NUMBER: _ClassVar[int]
+    P_TRIPLE_TERM_FIELD_NUMBER: _ClassVar[int]
+    O_IRI_FIELD_NUMBER: _ClassVar[int]
+    O_BNODE_FIELD_NUMBER: _ClassVar[int]
+    O_LITERAL_FIELD_NUMBER: _ClassVar[int]
+    O_TRIPLE_TERM_FIELD_NUMBER: _ClassVar[int]
+    G_IRI_FIELD_NUMBER: _ClassVar[int]
+    G_BNODE_FIELD_NUMBER: _ClassVar[int]
+    G_DEFAULT_GRAPH_FIELD_NUMBER: _ClassVar[int]
+    G_LITERAL_FIELD_NUMBER: _ClassVar[int]
+    s_iri: RdfIri
+    s_bnode: str
+    s_literal: RdfLiteral
+    s_triple_term: RdfTriple
+    p_iri: RdfIri
+    p_bnode: str
+    p_literal: RdfLiteral
+    p_triple_term: RdfTriple
+    o_iri: RdfIri
+    o_bnode: str
+    o_literal: RdfLiteral
+    o_triple_term: RdfTriple
+    g_iri: RdfIri
+    g_bnode: str
+    g_default_graph: RdfDefaultGraph
+    g_literal: RdfLiteral
+    def __init__(self, s_iri: _Optional[_Union[RdfIri, _Mapping]] = ..., s_bnode: _Optional[str] = ..., s_literal: _Optional[_Union[RdfLiteral, _Mapping]] = ..., s_triple_term: _Optional[_Union[RdfTriple, _Mapping]] = ..., p_iri: _Optional[_Union[RdfIri, _Mapping]] = ..., p_bnode: _Optional[str] = ..., p_literal: _Optional[_Union[RdfLiteral, _Mapping]] = ..., p_triple_term: _Optional[_Union[RdfTriple, _Mapping]] = ..., o_iri: _Optional[_Union[RdfIri, _Mapping]] = ..., o_bnode: _Optional[str] = ..., o_literal: _Optional[_Union[RdfLiteral, _Mapping]] = ..., o_triple_term: _Optional[_Union[RdfTriple, _Mapping]] = ..., g_iri: _Optional[_Union[RdfIri, _Mapping]] = ..., g_bnode: _Optional[str] = ..., g_default_graph: _Optional[_Union[RdfDefaultGraph, _Mapping]] = ..., g_literal: _Optional[_Union[RdfLiteral, _Mapping]] = ...) -> None: ...
+
+class RdfGraphStart(_message.Message):
+    __slots__ = ("g_iri", "g_bnode", "g_default_graph", "g_literal")
+    G_IRI_FIELD_NUMBER: _ClassVar[int]
+    G_BNODE_FIELD_NUMBER: _ClassVar[int]
+    G_DEFAULT_GRAPH_FIELD_NUMBER: _ClassVar[int]
+    G_LITERAL_FIELD_NUMBER: _ClassVar[int]
+    g_iri: RdfIri
+    g_bnode: str
+    g_default_graph: RdfDefaultGraph
+    g_literal: RdfLiteral
+    def __init__(self, g_iri: _Optional[_Union[RdfIri, _Mapping]] = ..., g_bnode: _Optional[str] = ..., g_default_graph: _Optional[_Union[RdfDefaultGraph, _Mapping]] = ..., g_literal: _Optional[_Union[RdfLiteral, _Mapping]] = ...) -> None: ...
+
+class RdfGraphEnd(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class RdfNamespaceDeclaration(_message.Message):
+    __slots__ = ("name", "value")
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    VALUE_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    value: RdfIri
+    def __init__(self, name: _Optional[str] = ..., value: _Optional[_Union[RdfIri, _Mapping]] = ...) -> None: ...
+
+class RdfNameEntry(_message.Message):
+    __slots__ = ("id", "value")
+    ID_FIELD_NUMBER: _ClassVar[int]
+    VALUE_FIELD_NUMBER: _ClassVar[int]
+    id: int
+    value: str
+    def __init__(self, id: _Optional[int] = ..., value: _Optional[str] = ...) -> None: ...
+
+class RdfPrefixEntry(_message.Message):
+    __slots__ = ("id", "value")
+    ID_FIELD_NUMBER: _ClassVar[int]
+    VALUE_FIELD_NUMBER: _ClassVar[int]
+    id: int
+    value: str
+    def __init__(self, id: _Optional[int] = ..., value: _Optional[str] = ...) -> None: ...
+
+class RdfDatatypeEntry(_message.Message):
+    __slots__ = ("id", "value")
+    ID_FIELD_NUMBER: _ClassVar[int]
+    VALUE_FIELD_NUMBER: _ClassVar[int]
+    id: int
+    value: str
+    def __init__(self, id: _Optional[int] = ..., value: _Optional[str] = ...) -> None: ...
+
+class RdfStreamOptions(_message.Message):
+    __slots__ = ("stream_name", "physical_type", "generalized_statements", "rdf_star", "max_name_table_size", "max_prefix_table_size", "max_datatype_table_size", "logical_type", "version")
+    STREAM_NAME_FIELD_NUMBER: _ClassVar[int]
+    PHYSICAL_TYPE_FIELD_NUMBER: _ClassVar[int]
+    GENERALIZED_STATEMENTS_FIELD_NUMBER: _ClassVar[int]
+    RDF_STAR_FIELD_NUMBER: _ClassVar[int]
+    MAX_NAME_TABLE_SIZE_FIELD_NUMBER: _ClassVar[int]
+    MAX_PREFIX_TABLE_SIZE_FIELD_NUMBER: _ClassVar[int]
+    MAX_DATATYPE_TABLE_SIZE_FIELD_NUMBER: _ClassVar[int]
+    LOGICAL_TYPE_FIELD_NUMBER: _ClassVar[int]
+    VERSION_FIELD_NUMBER: _ClassVar[int]
+    stream_name: str
+    physical_type: PhysicalStreamType
+    generalized_statements: bool
+    rdf_star: bool
+    max_name_table_size: int
+    max_prefix_table_size: int
+    max_datatype_table_size: int
+    logical_type: LogicalStreamType
+    version: int
+    def __init__(self, stream_name: _Optional[str] = ..., physical_type: _Optional[_Union[PhysicalStreamType, str]] = ..., generalized_statements: bool = ..., rdf_star: bool = ..., max_name_table_size: _Optional[int] = ..., max_prefix_table_size: _Optional[int] = ..., max_datatype_table_size: _Optional[int] = ..., logical_type: _Optional[_Union[LogicalStreamType, str]] = ..., version: _Optional[int] = ...) -> None: ...
+
+class RdfStreamRow(_message.Message):
+    __slots__ = ("options", "triple", "quad", "graph_start", "graph_end", "namespace", "name", "prefix", "datatype")
+    OPTIONS_FIELD_NUMBER: _ClassVar[int]
+    TRIPLE_FIELD_NUMBER: _ClassVar[int]
+    QUAD_FIELD_NUMBER: _ClassVar[int]
+    GRAPH_START_FIELD_NUMBER: _ClassVar[int]
+    GRAPH_END_FIELD_NUMBER: _ClassVar[int]
+    NAMESPACE_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    PREFIX_FIELD_NUMBER: _ClassVar[int]
+    DATATYPE_FIELD_NUMBER: _ClassVar[int]
+    options: RdfStreamOptions
+    triple: RdfTriple
+    quad: RdfQuad
+    graph_start: RdfGraphStart
+    graph_end: RdfGraphEnd
+    namespace: RdfNamespaceDeclaration
+    name: RdfNameEntry
+    prefix: RdfPrefixEntry
+    datatype: RdfDatatypeEntry
+    def __init__(self, options: _Optional[_Union[RdfStreamOptions, _Mapping]] = ..., triple: _Optional[_Union[RdfTriple, _Mapping]] = ..., quad: _Optional[_Union[RdfQuad, _Mapping]] = ..., graph_start: _Optional[_Union[RdfGraphStart, _Mapping]] = ..., graph_end: _Optional[_Union[RdfGraphEnd, _Mapping]] = ..., namespace: _Optional[_Union[RdfNamespaceDeclaration, _Mapping]] = ..., name: _Optional[_Union[RdfNameEntry, _Mapping]] = ..., prefix: _Optional[_Union[RdfPrefixEntry, _Mapping]] = ..., datatype: _Optional[_Union[RdfDatatypeEntry, _Mapping]] = ...) -> None: ...
+
+class RdfStreamFrame(_message.Message):
+    __slots__ = ("rows", "metadata")
+    class MetadataEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: bytes
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[bytes] = ...) -> None: ...
+    ROWS_FIELD_NUMBER: _ClassVar[int]
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    rows: _containers.RepeatedCompositeFieldContainer[RdfStreamRow]
+    metadata: _containers.ScalarMap[str, bytes]
+    def __init__(self, rows: _Optional[_Iterable[_Union[RdfStreamRow, _Mapping]]] = ..., metadata: _Optional[_Mapping[str, bytes]] = ...) -> None: ...