pyjelly 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

pyjelly/integrations/rdflib/parse.py

@@ -12,8 +12,8 @@ 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.options import StreamTypes
+from pyjelly.parse.decode import Adapter, Decoder, ParserOptions
 from pyjelly.parse.ioutils import get_options_and_frames
 
 
@@ -40,11 +40,9 @@ class RDFLibAdapter(Adapter):
         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)
+def _adapter_missing(feature: str, *, stream_types: StreamTypes) -> Never:
+    physical_type_name = jelly.PhysicalStreamType.Name(stream_types.physical_type)
+    logical_type_name = jelly.LogicalStreamType.Name(stream_types.logical_type)
     msg = (
         f"adapter with {physical_type_name} and {logical_type_name} "
         f"does not implement {feature}"
@@ -55,9 +53,9 @@ def _adapter_missing(feature: str, *, options: StreamOptions) -> Never:
 class RDFLibTriplesAdapter(RDFLibAdapter):
     graph: Graph
 
-    def __init__(self, graph: Graph, options: StreamOptions) -> None:
+    def __init__(self, options: ParserOptions, store: Store | str = "default") -> None:
         super().__init__(options=options)
-        self.graph = graph
+        self.graph = Graph(store=store)
 
     @override
     def triple(self, terms: Iterable[Any]) -> Any:
@@ -77,26 +75,39 @@ class RDFLibTriplesAdapter(RDFLibAdapter):
             jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES,
         ):
             return None
-        return _adapter_missing("interpreting frames", options=self.options)
+        return _adapter_missing(
+            "interpreting frames",
+            stream_types=self.options.stream_types,
+        )
 
 
 class RDFLibQuadsBaseAdapter(RDFLibAdapter):
-    def __init__(self, dataset: Dataset, options: StreamOptions) -> None:
+    def __init__(
+        self,
+        options: ParserOptions,
+        store: Store | str,
+    ) -> None:
         super().__init__(options=options)
-        self.dataset = dataset
+        self.store = store
+        self.dataset = self.new_dataset()
+
+    def new_dataset(self) -> Dataset:
+        return Dataset(store=self.store, default_union=True)
 
     @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)
+            self.dataset = self.new_dataset()
             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)
+        return _adapter_missing(
+            "interpreting frames", stream_types=self.options.stream_types
+        )
 
 
 class RDFLibQuadsAdapter(RDFLibQuadsBaseAdapter):
@@ -112,8 +123,12 @@ class RDFLibQuadsAdapter(RDFLibQuadsBaseAdapter):
 class RDFLibGraphsAdapter(RDFLibQuadsBaseAdapter):
     _graph: Graph | None = None
 
-    def __init__(self, dataset: Dataset, options: StreamOptions) -> None:
-        super().__init__(dataset=dataset, options=options)
+    def __init__(
+        self,
+        options: ParserOptions,
+        store: Store | str,
+    ) -> None:
+        super().__init__(options=options, store=store)
         self._graph = None
 
     @property
@@ -144,90 +159,134 @@ class RDFLibGraphsAdapter(RDFLibQuadsBaseAdapter):
         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)
+            self.dataset = self.new_dataset()
             return this_dataset
         return super().frame()
 
 
-def parse_flat_stream(
+def parse_flat_triples_stream(
     frames: Iterable[jelly.RdfStreamFrame],
-    sink: Graph,
-    options: StreamOptions,
+    options: ParserOptions,
+    store: Store | str = "default",
+    identifier: str | None = None,
 ) -> 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)
+    assert options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES
+    adapter = RDFLibTriplesAdapter(options, store=store)
+    if identifier is not None:
+        adapter.graph = Graph(identifier=identifier, store=store)
     decoder = Decoder(adapter=adapter)
     for frame in frames:
         decoder.decode_frame(frame=frame)
-    return ds or sink
+    return adapter.graph
 
 
-def parse_grouped_graph_stream(
+def parse_flat_quads_stream(
     frames: Iterable[jelly.RdfStreamFrame],
-    sink: Graph,
-    options: StreamOptions,
+    options: ParserOptions,
+    store: Store | str = "default",
+    identifier: str | None = None,
 ) -> Dataset:
-    adapter = RDFLibTriplesAdapter(graph=sink, options=options)
-    ds = Dataset(store=sink.store, default_union=True)
-    ds.default_context = sink
+    assert options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS
+    adapter_class: type[RDFLibQuadsBaseAdapter]
+    if options.stream_types.physical_type == jelly.PHYSICAL_STREAM_TYPE_QUADS:
+        adapter_class = RDFLibQuadsAdapter
+    else:  # jelly.PHYSICAL_STREAM_TYPE_GRAPHS
+        adapter_class = RDFLibGraphsAdapter
+    adapter = adapter_class(options=options, store=store)
+    adapter.dataset.default_context = Graph(identifier=identifier, store=store)
     decoder = Decoder(adapter=adapter)
     for frame in frames:
-        graph = decoder.decode_frame(frame=frame)
-        ds.add_graph(graph)
-    return ds
+        decoder.decode_frame(frame=frame)
+    return adapter.dataset
 
 
-def parse_grouped_dataset_stream(
+def parse_graph_stream(
     frames: Iterable[jelly.RdfStreamFrame],
-    options: StreamOptions,
+    options: ParserOptions,
     store: Store | str = "default",
-) -> Generator[Dataset]:
-    adapter = RDFLibGraphsAdapter(dataset=Dataset(store=store), options=options)
+) -> Generator[Graph]:
+    assert options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_GRAPHS
+    adapter = RDFLibTriplesAdapter(options, store=store)
     decoder = Decoder(adapter=adapter)
     for frame in frames:
         yield decoder.decode_frame(frame=frame)
 
 
-def graph_or_dataset_from_jelly(
+def graphs_from_jelly(
     inp: IO[bytes],
-    sink: Graph,
-) -> Dataset | Graph:
+    store: Store | str = "default",
+) -> Generator[Any] | Generator[Dataset] | Generator[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.logical_type == jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES:
+        yield parse_flat_triples_stream(frames=frames, options=options, store=store)
+        return
 
-    if options.stream_types.physical_type == jelly.PHYSICAL_STREAM_TYPE_TRIPLES:
-        return parse_grouped_graph_stream(frames=frames, sink=sink, options=options)
+    if options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS:
+        yield parse_flat_quads_stream(frames=frames, options=options, store=store)
+        return
 
-    msg = (
-        "the stream contains multiple datasets and cannot be parsed into "
-        "a single dataset"
-    )
+    if options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_GRAPHS:
+        yield from parse_graph_stream(frames=frames, options=options, store=store)
+        return
+
+    logical_type_name = jelly.LogicalStreamType.Name(options.stream_types.logical_type)
+    msg = f"the stream type {logical_type_name} is not supported "
+    raise NotImplementedError(msg)
+
+
+def graph_from_jelly(
+    inp: IO[bytes],
+    store: Store | str = "default",
+    identifier: str | None = None,
+) -> Any | Dataset | Graph:
+    options, frames = get_options_and_frames(inp)
+
+    if options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_DATASETS:
+        msg = (
+            "the stream contains multiple datasets and cannot be parsed into "
+            "a single dataset"
+        )
+        raise NotImplementedError(msg)
+
+    if options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES:
+        return parse_flat_triples_stream(
+            frames=frames,
+            options=options,
+            store=store,
+            identifier=identifier,
+        )
+
+    if options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS:
+        return parse_flat_quads_stream(
+            frames=frames,
+            options=options,
+            store=store,
+            identifier=identifier,
+        )
+
+    if options.stream_types.logical_type == jelly.LOGICAL_STREAM_TYPE_GRAPHS:
+        ds = Dataset(store=store, default_union=True)
+        ds.default_context = Graph(identifier=identifier, store=store)
+
+        for graph in parse_graph_stream(frames=frames, options=options, store=store):
+            ds.add_graph(graph)
+
+        return ds
+
+    logical_type_name = jelly.LogicalStreamType.Name(options.stream_types.logical_type)
+    msg = f"the stream type {logical_type_name} is not supported "
     raise NotImplementedError(msg)
 
 
 class RDFLibJellyParser(RDFLibParser):
-    def parse(
-        self,
-        source: InputSource,
-        sink: Graph,
-    ) -> None:
+    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)
+        graph_from_jelly(
+            inp,
+            identifier=sink.identifier,
+            store=sink.store,
+        )

pyjelly/integrations/rdflib/serialize.py

@@ -12,7 +12,13 @@ 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
+from pyjelly.serialize.streams import (
+    GraphStream,
+    QuadStream,
+    SerializerOptions,
+    Stream,
+    TripleStream,
+)
 
 
 class RDFLibTermEncoder(TermEncoder):
@@ -49,44 +55,57 @@ def stream_frames(stream: Stream, data: Graph) -> Generator[jelly.RdfStreamFrame
     raise TypeError(msg)
 
 
-@stream_frames.register
-def triples_stream(
+@stream_frames.register(TripleStream)
+def triples_stream_frames(
     stream: TripleStream,
-    data: Graph,
+    data: Graph | Dataset,
 ) -> Generator[jelly.RdfStreamFrame]:
-    assert not isinstance(data, Dataset)
     stream.enroll()
-    if stream.options.namespace_declarations:
+    if stream.options.params.namespace_declarations:
         namespace_declarations(data, stream)
-    for terms in data:
-        if frame := stream.triple(terms):
+    graphs = (data,) if not isinstance(data, Dataset) else data.graphs()
+    for graph in graphs:
+        for terms in graph:
+            if frame := stream.triple(terms):
+                yield frame
+        if frame := stream.flow.frame_from_graph():
             yield frame
-    if frame := stream.flow.to_stream_frame():
+    if stream.stream_types.flat and (frame := stream.flow.to_stream_frame()):
         yield frame
 
 
 @stream_frames.register
-def quads_stream(stream: QuadStream, data: Graph) -> Generator[jelly.RdfStreamFrame]:
+def quads_stream_frames(
+    stream: QuadStream,
+    data: Dataset,
+) -> Generator[jelly.RdfStreamFrame]:
     assert isinstance(data, Dataset)
     stream.enroll()
-    if stream.options.namespace_declarations:
+    if stream.options.params.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():
+    if frame := stream.flow.frame_from_dataset():
+        yield frame
+    if stream.stream_types.flat and (frame := stream.flow.to_stream_frame()):
         yield frame
 
 
 @stream_frames.register
-def graphs_stream(stream: GraphStream, data: Graph) -> Generator[jelly.RdfStreamFrame]:
+def graphs_stream_frames(
+    stream: GraphStream,
+    data: Dataset,
+) -> Generator[jelly.RdfStreamFrame]:
     assert isinstance(data, Dataset)
     stream.enroll()
-    if stream.options.namespace_declarations:
+    if stream.options.params.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():
+    if frame := stream.flow.frame_from_dataset():
+        yield frame
+    if stream.stream_types.flat and (frame := stream.flow.to_stream_frame()):
         yield frame
 
 
@@ -105,15 +124,57 @@ class RDFLibJellySerializer(RDFLibSerializer):
             raise NotImplementedError(msg)
         super().__init__(store)
 
+    def guess_options(self) -> SerializerOptions:
+        """
+        Guess the serializer options based on the store type.
+
+        >>> RDFLibJellySerializer(Graph()).guess_options().logical_type
+        1
+        >>> RDFLibJellySerializer(Dataset()).guess_options().logical_type
+        2
+        """
+        logical_type = (
+            jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS
+            if isinstance(self.store, Dataset)
+            else jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES
+        )
+        return SerializerOptions(logical_type=logical_type)
+
+    def guess_stream(self, options: SerializerOptions) -> Stream:
+        """
+        Return an appropriate stream implementation for the given options.
+
+        >>> graph_ser = RDFLibJellySerializer(Graph())
+        >>> ds_ser = RDFLibJellySerializer(Dataset())
+
+        >>> type(graph_ser.guess_stream(graph_ser.guess_options()))
+        <class 'pyjelly.serialize.streams.TripleStream'>
+        >>> type(ds_ser.guess_stream(ds_ser.guess_options()))
+        <class 'pyjelly.serialize.streams.QuadStream'>
+        """
+        stream_cls: type[Stream]
+        if options.logical_type != jelly.LOGICAL_STREAM_TYPE_GRAPHS and isinstance(
+            self.store, Dataset
+        ):
+            stream_cls = QuadStream
+        else:
+            stream_cls = TripleStream
+        return stream_cls.for_rdflib(options=options)
+
     @override
     def serialize(  # type: ignore[override]
         self,
         out: IO[bytes],
         /,
         *,
-        stream: Stream,
+        stream: Stream | None = None,
+        options: SerializerOptions | None = None,
         **unused: Any,
     ) -> None:
-        write = write_delimited if stream.options.delimited else write_single
+        if options is None:
+            options = self.guess_options()
+        if stream is None:
+            stream = self.guess_stream(options)
+        write = write_delimited if stream.options.params.delimited else write_single
         for stream_frame in stream_frames(stream, self.store):
             write(stream_frame, out)

pyjelly/options.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import mimetypes
 from contextlib import suppress
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Final
 from typing_extensions import Self
 
@@ -10,7 +10,6 @@ from pyjelly import jelly
 from pyjelly.errors import (
     JellyAssertionError,
     JellyConformanceError,
-    JellyNotImplementedError,
 )
 
 MIN_NAME_LOOKUP_SIZE: Final[int] = 8
@@ -65,7 +64,7 @@ class LookupPreset:
 
 @dataclass(frozen=True)
 class StreamTypes:
-    physical_type: jelly.PhysicalStreamType
+    physical_type: jelly.PhysicalStreamType = jelly.PHYSICAL_STREAM_TYPE_UNSPECIFIED
     logical_type: jelly.LogicalStreamType = jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED
 
     @property
@@ -83,9 +82,6 @@ class StreamTypes:
         return f"StreamTypes({self.physical_type}, {self.logical_type})"
 
     def __post_init__(self) -> None:
-        if self.physical_type == jelly.PHYSICAL_STREAM_TYPE_UNSPECIFIED:
-            msg = "physical type must be specified"
-            raise JellyNotImplementedError(msg)
         validate_type_compatibility(
             physical_type=self.physical_type,
             logical_type=self.logical_type,
@@ -93,9 +89,7 @@ class StreamTypes:
 
 
 @dataclass(frozen=True)
-class StreamOptions:
-    stream_types: StreamTypes
-    lookup_preset: LookupPreset = field(default_factory=LookupPreset)
+class StreamParameters:
     generalized_statements: bool = False
     rdf_star: bool = False
     version: int = MAX_VERSION
@@ -115,7 +109,10 @@ def validate_type_compatibility(
     physical_type: jelly.PhysicalStreamType,
     logical_type: jelly.LogicalStreamType,
 ) -> None:
-    if logical_type == jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED:
+    if (
+        physical_type == jelly.PHYSICAL_STREAM_TYPE_UNSPECIFIED
+        or logical_type == jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED
+    ):
         return
     triples_physical_type = physical_type == jelly.PHYSICAL_STREAM_TYPE_TRIPLES
     triples_logical_type = logical_type in TRIPLES_ONLY_LOGICAL_TYPES

pyjelly/parse/decode.py

@@ -2,22 +2,28 @@ from __future__ import annotations
 
 from abc import ABCMeta, abstractmethod
 from collections.abc import Iterable, Sequence
-from typing import Any, ClassVar
+from typing import Any, ClassVar, NamedTuple
 from typing_extensions import Never
 
 from pyjelly import jelly
-from pyjelly.options import LookupPreset, StreamOptions, StreamTypes
+from pyjelly.options import LookupPreset, StreamParameters, StreamTypes
 from pyjelly.parse.lookup import LookupDecoder
 
 
+class ParserOptions(NamedTuple):
+    stream_types: StreamTypes
+    lookup_preset: LookupPreset
+    params: StreamParameters
+
+
 def options_from_frame(
     frame: jelly.RdfStreamFrame,
     *,
     delimited: bool,
-) -> StreamOptions:
+) -> ParserOptions:
     row = frame.rows[0]
     options = row.options
-    return StreamOptions(
+    return ParserOptions(
         stream_types=StreamTypes(
             physical_type=options.physical_type,
             logical_type=options.logical_type,
@@ -27,17 +33,17 @@ def options_from_frame(
             max_prefixes=options.max_prefix_table_size,
             max_datatypes=options.max_datatype_table_size,
         ),
-        stream_name=options.stream_name,
-        version=options.version,
-        delimited=delimited,
+        params=StreamParameters(
+            stream_name=options.stream_name,
+            version=options.version,
+            delimited=delimited,
+        ),
     )
 
 
-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)
+def _adapter_missing(feature: str, *, stream_types: StreamTypes) -> Never:
+    physical_type_name = jelly.PhysicalStreamType.Name(stream_types.physical_type)
+    logical_type_name = jelly.LogicalStreamType.Name(stream_types.logical_type)
     msg = (
         f"adapter with {physical_type_name} and {logical_type_name} "
         f"does not implement {feature}"
@@ -46,7 +52,7 @@ def _adapter_missing(feature: str, *, options: StreamOptions) -> Never:
 
 
 class Adapter(metaclass=ABCMeta):
-    def __init__(self, options: StreamOptions) -> None:
+    def __init__(self, options: ParserOptions) -> None:
         self.options = options
 
     # Obligatory abstract methods--all adapters must implement these
@@ -73,19 +79,26 @@ class Adapter(metaclass=ABCMeta):
 
     # Optional abstract methods--not required to be implemented by all adapters
     def triple(self, terms: Iterable[Any]) -> Any:  # noqa: ARG002
-        _adapter_missing("decoding triples", options=self.options)
+        _adapter_missing("decoding triples", stream_types=self.options.stream_types)
 
     def quad(self, terms: Iterable[Any]) -> Any:  # noqa: ARG002
-        _adapter_missing("decoding quads", options=self.options)
+        _adapter_missing("decoding quads", stream_types=self.options.stream_types)
 
     def graph_start(self, graph_id: Any) -> Any:  # noqa: ARG002
-        _adapter_missing("decoding graph start markers", options=self.options)
+        _adapter_missing(
+            "decoding graph start markers", stream_types=self.options.stream_types
+        )
 
     def graph_end(self) -> Any:
-        _adapter_missing("decoding graph end markers", options=self.options)
+        _adapter_missing(
+            "decoding graph end markers", stream_types=self.options.stream_types
+        )
 
     def namespace_declaration(self, name: str, iri: str) -> Any:  # noqa: ARG002
-        _adapter_missing("decoding namespace declarations", options=self.options)
+        _adapter_missing(
+            "decoding namespace declarations",
+            stream_types=self.options.stream_types,
+        )
 
     def frame(self) -> Any:
         return None
@@ -104,7 +117,7 @@ class Decoder:
         self.repeated_terms: dict[str, jelly.RdfIri | str | jelly.RdfLiteral] = {}
 
     @property
-    def options(self) -> StreamOptions:
+    def options(self) -> ParserOptions:
         return self.adapter.options
 
     def decode_frame(self, frame: jelly.RdfStreamFrame) -> Any:
@@ -122,13 +135,14 @@ class Decoder:
         return decode_row(self, row)
 
     def validate_stream_options(self, options: jelly.RdfStreamOptions) -> None:
-        assert self.options.stream_name == options.stream_name
-        assert self.options.version >= options.version
-        assert self.options.lookup_preset.max_prefixes == options.max_prefix_table_size
-        assert (
-            self.options.lookup_preset.max_datatypes == options.max_datatype_table_size
-        )
-        assert self.options.lookup_preset.max_names == options.max_name_table_size
+        stream_types, lookup_preset, params = self.options
+        assert stream_types.physical_type == options.physical_type
+        assert stream_types.logical_type == options.logical_type
+        assert params.stream_name == options.stream_name
+        assert params.version >= options.version
+        assert lookup_preset.max_prefixes == options.max_prefix_table_size
+        assert lookup_preset.max_datatypes == options.max_datatype_table_size
+        assert lookup_preset.max_names == options.max_name_table_size
 
     def ingest_prefix_entry(self, entry: jelly.RdfPrefixEntry) -> None:
         self.prefixes.assign_entry(index=entry.id, value=entry.value)

pyjelly/parse/ioutils.py

@@ -7,8 +7,7 @@ from google.protobuf.proto import parse, parse_length_prefixed
 
 from pyjelly import jelly
 from pyjelly.errors import JellyConformanceError
-from pyjelly.options import StreamOptions
-from pyjelly.parse.decode import options_from_frame
+from pyjelly.parse.decode import ParserOptions, options_from_frame
 
 
 def delimited_jelly_hint(header: bytes) -> bool:
@@ -62,7 +61,7 @@ def frame_iterator(inp: IO[bytes]) -> Generator[jelly.RdfStreamFrame]:
 
 def get_options_and_frames(
     inp: IO[bytes],
-) -> tuple[StreamOptions, Iterator[jelly.RdfStreamFrame]]:
+) -> tuple[ParserOptions, Iterator[jelly.RdfStreamFrame]]:
     is_delimited = delimited_jelly_hint(bytes_read := inp.read(3))
     inp.seek(-len(bytes_read), os.SEEK_CUR)
 

pyjelly/serialize/encode.py

@@ -37,24 +37,24 @@ class TermEncoder:
 
     def __init__(
         self,
-        max_names: int = options.DEFAULT_NAME_LOOKUP_SIZE,
-        max_prefixes: int = options.DEFAULT_PREFIX_LOOKUP_SIZE,
-        max_datatypes: int = options.DEFAULT_DATATYPE_LOOKUP_SIZE,
+        lookup_preset: options.LookupPreset | None = None,
     ) -> None:
-        self.names = LookupEncoder(lookup_size=max_names)
-        self.prefixes = LookupEncoder(lookup_size=max_prefixes)
-        self.datatypes = LookupEncoder(lookup_size=max_datatypes)
+        if lookup_preset is None:
+            lookup_preset = options.LookupPreset()
+        self.lookup_preset = lookup_preset
+        self.names = LookupEncoder(lookup_size=lookup_preset.max_names)
+        self.prefixes = LookupEncoder(lookup_size=lookup_preset.max_prefixes)
+        self.datatypes = LookupEncoder(lookup_size=lookup_preset.max_datatypes)
 
     def encode_iri(self, iri_string: str) -> RowsAnd[jelly.RdfIri]:
         prefix, name = split_iri(iri_string)
-        if prefix and self.prefixes.lookup.max_size:
+        if self.prefixes.lookup.max_size:
             prefix_entry_index = self.prefixes.encode_entry_index(prefix)
         else:
             name = iri_string
             prefix_entry_index = None
 
         name_entry_index = self.names.encode_entry_index(name)
-
         term_rows = []
 
         if prefix_entry_index is not None:
@@ -124,11 +124,6 @@ class Slot(str, Enum):
         return self.value
 
 
-def new_repeated_terms() -> dict[Slot, object]:
-    """Create a new dictionary for repeated terms."""
-    return dict.fromkeys(Slot)
-
-
 def encode_statement(
     terms: Iterable[object],
     term_encoder: TermEncoder,
@@ -181,17 +176,21 @@ def encode_namespace_declaration(
     return rows
 
 
-def encode_options(options: options.StreamOptions) -> jelly.RdfStreamRow:
+def encode_options(
+    lookup_preset: options.LookupPreset,
+    stream_types: options.StreamTypes,
+    params: options.StreamParameters,
+) -> jelly.RdfStreamRow:
     return jelly.RdfStreamRow(
         options=jelly.RdfStreamOptions(
-            stream_name=options.stream_name,
-            physical_type=options.stream_types.physical_type,
-            generalized_statements=options.generalized_statements,
-            rdf_star=options.rdf_star,
-            max_name_table_size=options.lookup_preset.max_names,
-            max_prefix_table_size=options.lookup_preset.max_prefixes,
-            max_datatype_table_size=options.lookup_preset.max_datatypes,
-            logical_type=options.stream_types.logical_type,
-            version=options.version,
+            stream_name=params.stream_name,
+            physical_type=stream_types.physical_type,
+            generalized_statements=params.generalized_statements,
+            rdf_star=params.rdf_star,
+            max_name_table_size=lookup_preset.max_names,
+            max_prefix_table_size=lookup_preset.max_prefixes,
+            max_datatype_table_size=lookup_preset.max_datatypes,
+            logical_type=stream_types.logical_type,
+            version=params.version,
         )
     )

pyjelly/serialize/flows.py

@@ -8,6 +8,8 @@ from typing_extensions import override
 
 from pyjelly import jelly
 
+DEFAULT_FRAME_SIZE = 250
+
 
 class FrameFlow(UserList[jelly.RdfStreamRow]):
     """
@@ -16,9 +18,25 @@ class FrameFlow(UserList[jelly.RdfStreamRow]):
     Collects stream rows and assembles them into RdfStreamFrame objects when ready.
     """
 
-    logical_type: ClassVar[jelly.LogicalStreamType]
+    logical_type: jelly.LogicalStreamType
     registry: ClassVar[dict[jelly.LogicalStreamType, type[FrameFlow]]] = {}
 
+    def frame_from_graph(self) -> jelly.RdfStreamFrame | None:
+        """
+        Treat the current rows as a graph and produce a frame.
+
+        Default implementation returns None.
+        """
+        return None
+
+    def frame_from_dataset(self) -> jelly.RdfStreamFrame | None:
+        """
+        Treat the current rows as a dataset and produce a frame.
+
+        Default implementation returns None.
+        """
+        return None
+
     def frame_from_bounds(self) -> jelly.RdfStreamFrame | None:
         return None
 
@@ -29,15 +47,6 @@ class FrameFlow(UserList[jelly.RdfStreamRow]):
         self.clear()
         return frame
 
-    def __init_subclass__(cls) -> None:
-        """
-        Register subclasses of FrameFlow with their logical stream type.
-
-        This allows for dynamic dispatch based on the logical stream type.
-        """
-        if cls.logical_type != jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED:
-            cls.registry[cls.logical_type] = cls
-
 
 class ManualFrameFlow(FrameFlow):
     """
@@ -52,6 +61,15 @@ class ManualFrameFlow(FrameFlow):
 
     logical_type = jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED
 
+    def __init__(
+        self,
+        initlist: Iterable[jelly.RdfStreamRow] | None = None,
+        *,
+        logical_type: jelly.LogicalStreamType = jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED,
+    ) -> None:
+        super().__init__(initlist)
+        self.logical_type = logical_type
+
 
 @dataclass
 class BoundedFrameFlow(FrameFlow):
@@ -62,9 +80,7 @@ class BoundedFrameFlow(FrameFlow):
     """
 
     logical_type = jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED
-
     frame_size: int
-    default_frame_size: ClassVar[int] = 250
 
     def __init__(
         self,
@@ -73,7 +89,7 @@ class BoundedFrameFlow(FrameFlow):
         frame_size: int | None = None,
     ) -> None:
         super().__init__(initlist)
-        self.frame_size = frame_size or self.default_frame_size
+        self.frame_size = frame_size or DEFAULT_FRAME_SIZE
 
     @override
     def frame_from_bounds(self) -> jelly.RdfStreamFrame | None:
@@ -82,13 +98,42 @@ class BoundedFrameFlow(FrameFlow):
         return None
 
 
-# Fallback for unspecified logical types
-FrameFlow.registry[jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED] = BoundedFrameFlow
-
-
 class FlatTriplesFrameFlow(BoundedFrameFlow):
     logical_type = jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES
 
 
 class FlatQuadsFrameFlow(BoundedFrameFlow):
     logical_type = jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS
+
+
+class GraphsFrameFlow(FrameFlow):
+    logical_type = jelly.LOGICAL_STREAM_TYPE_GRAPHS
+
+    def frame_from_graph(self) -> jelly.RdfStreamFrame | None:
+        return self.to_stream_frame()
+
+
+class DatasetsFrameFlow(FrameFlow):
+    logical_type = jelly.LOGICAL_STREAM_TYPE_DATASETS
+
+    def frame_from_dataset(self) -> jelly.RdfStreamFrame | None:
+        return self.to_stream_frame()
+
+
+FLOW_DISPATCH: dict[jelly.LogicalStreamType, type[FrameFlow]] = {
+    jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES: FlatTriplesFrameFlow,
+    jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS: FlatQuadsFrameFlow,
+    jelly.LOGICAL_STREAM_TYPE_GRAPHS: GraphsFrameFlow,
+    jelly.LOGICAL_STREAM_TYPE_DATASETS: DatasetsFrameFlow,
+}
+
+
+def flow_for_type(logical_type: jelly.LogicalStreamType) -> type[FrameFlow]:
+    try:
+        return FLOW_DISPATCH[logical_type]
+    except KeyError:
+        msg = (
+            "unsupported logical stream type: "
+            f"{jelly.LogicalStreamType.Name(logical_type)}"
+        )
+        raise NotImplementedError(msg) from None

pyjelly/serialize/lookup.py

@@ -108,11 +108,13 @@ class LookupEncoder:
         return current_index
 
     def encode_prefix_term_index(self, value: str) -> int:
-        if not value or self.lookup.max_size == 0:
+        if self.lookup.max_size == 0:
             return 0
         previous_index = self.last_reused_index
+        if not value and previous_index == 0:
+            return 0
         current_index = self.encode_term_index(value)
-        if value and previous_index == 0:
+        if previous_index == 0:
             return current_index
         if current_index == previous_index:
             return 0

pyjelly/serialize/streams.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 from collections.abc import Generator, Iterable
+from dataclasses import dataclass, field
 from typing import Any, ClassVar
 
 from pyjelly import jelly
-from pyjelly.options import StreamOptions
+from pyjelly.options import LookupPreset, StreamParameters, StreamTypes
 from pyjelly.serialize.encode import (
     Slot,
     TermEncoder,
@@ -12,61 +13,84 @@ from pyjelly.serialize.encode import (
     encode_options,
     encode_quad,
     encode_triple,
-    new_repeated_terms,
 )
-from pyjelly.serialize.flows import FrameFlow, ManualFrameFlow
+from pyjelly.serialize.flows import (
+    DEFAULT_FRAME_SIZE,
+    BoundedFrameFlow,
+    FlatQuadsFrameFlow,
+    FlatTriplesFrameFlow,
+    FrameFlow,
+    ManualFrameFlow,
+    flow_for_type,
+)
+
+
+@dataclass
+class SerializerOptions:
+    flow: FrameFlow | None = None
+    frame_size: int = DEFAULT_FRAME_SIZE
+    logical_type: jelly.LogicalStreamType = jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED
+    params: StreamParameters = field(default_factory=StreamParameters)
+    lookup_preset: LookupPreset = field(default_factory=LookupPreset)
 
 
 class Stream:
     physical_type: ClassVar[jelly.PhysicalStreamType]
-    registry: ClassVar[dict[jelly.PhysicalStreamType, type[Stream]]] = {}
-    flow: FrameFlow
+    default_delimited_flow_class: ClassVar[type[BoundedFrameFlow]]
 
     def __init__(
         self,
         *,
-        options: StreamOptions,
-        encoder_class: type[TermEncoder],
-        **flow_args: Any,
+        encoder: TermEncoder,
+        options: SerializerOptions | None = None,
     ) -> None:
-        assert options.stream_types.physical_type == self.physical_type
+        self.encoder = encoder
+        if options is None:
+            options = SerializerOptions()
         self.options = options
-        self.encoder = encoder_class(
-            max_prefixes=options.lookup_preset.max_prefixes,
-            max_names=options.lookup_preset.max_names,
-            max_datatypes=options.lookup_preset.max_datatypes,
-        )
-        flow_class = FrameFlow.registry[self.options.stream_types.logical_type]
-        if not options.delimited:
-            flow_class = ManualFrameFlow
-        self.flow = flow_class(**flow_args)
-        self.repeated_terms = new_repeated_terms()
+        flow = options.flow
+        if flow is None:
+            flow = self.infer_flow()
+        self.flow = flow
+        self.repeated_terms = dict.fromkeys(Slot)
         self.enrolled = False
-
-    @staticmethod
-    def from_options(
-        options: StreamOptions,
-        encoder_class: type[TermEncoder] | None = None,
-        **flow_args: Any,
-    ) -> Any:
-        if encoder_class is None:
-            from pyjelly.integrations.rdflib.serialize import RDFLibTermEncoder
-
-            encoder_class = RDFLibTermEncoder
-        stream_class = Stream.registry[options.stream_types.physical_type]
-        return stream_class(
-            options=options,
-            encoder_class=encoder_class,
-            **flow_args,
+        self.stream_types = StreamTypes(
+            physical_type=self.physical_type,
+            logical_type=self.flow.logical_type,
         )
 
+    def infer_flow(self) -> FrameFlow:
+        flow: FrameFlow
+        if self.options.params.delimited:
+            if self.options.logical_type != jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED:
+                flow_class = flow_for_type(self.options.logical_type)
+            else:
+                flow_class = self.default_delimited_flow_class
+
+            if self.options.logical_type in (
+                jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES,
+                jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS,
+            ):
+                flow = flow_class(frame_size=self.options.frame_size)  # type: ignore[call-overload]
+            else:
+                flow = flow_class()
+        else:
+            flow = ManualFrameFlow(logical_type=self.options.logical_type)
+        return flow
+
     def enroll(self) -> None:
         if not self.enrolled:
             self.stream_options()
             self.enrolled = True
 
     def stream_options(self) -> None:
-        self.flow.append(encode_options(self.options))
+        self.flow.append(
+            encode_options(
+                stream_types=self.stream_types,
+                params=self.options.params,
+                lookup_preset=self.options.lookup_preset,
+            )
+        )
 
     def namespace_declaration(self, name: str, iri: str) -> None:
         rows = encode_namespace_declaration(
@@ -76,12 +100,37 @@ class Stream:
         )
         self.flow.extend(rows)
 
-    def __init_subclass__(cls) -> None:
-        cls.registry[cls.physical_type] = cls
+    @classmethod
+    def for_rdflib(cls, options: SerializerOptions | None = None) -> Stream:
+        if cls is Stream:
+            msg = "Stream is an abstract base class, use a subclass instead"
+            raise TypeError(msg)
+        from pyjelly.integrations.rdflib.serialize import RDFLibTermEncoder
+
+        lookup_preset: LookupPreset | None = None
+        if options is not None:
+            lookup_preset = options.lookup_preset
+        return cls(
+            encoder=RDFLibTermEncoder(lookup_preset=lookup_preset),
+            options=options,
+        )
+
+
+def stream_for_type(physical_type: jelly.PhysicalStreamType) -> type[Stream]:
+    try:
+        stream_cls = STREAM_DISPATCH[physical_type]
+    except KeyError:
+        msg = (
+            "no stream class for physical type "
+            f"{jelly.PhysicalStreamType.Name(physical_type)}"
+        )
+        raise NotImplementedError(msg) from None
+    return stream_cls
 
 
 class TripleStream(Stream):
     physical_type = jelly.PHYSICAL_STREAM_TYPE_TRIPLES
+    default_delimited_flow_class: ClassVar = FlatTriplesFrameFlow
 
     def triple(self, terms: Iterable[object]) -> jelly.RdfStreamFrame | None:
         new_rows = encode_triple(
@@ -90,13 +139,12 @@ class TripleStream(Stream):
             repeated_terms=self.repeated_terms,
         )
         self.flow.extend(new_rows)
-        if frame := self.flow.frame_from_bounds():
-            return frame
-        return None
+        return self.flow.frame_from_bounds()
 
 
 class QuadStream(Stream):
     physical_type = jelly.PHYSICAL_STREAM_TYPE_QUADS
+    default_delimited_flow_class: ClassVar = FlatQuadsFrameFlow
 
     def quad(self, terms: Iterable[object]) -> jelly.RdfStreamFrame | None:
         new_rows = encode_quad(
@@ -105,13 +153,12 @@ class QuadStream(Stream):
             repeated_terms=self.repeated_terms,
         )
         self.flow.extend(new_rows)
-        if frame := self.flow.frame_from_bounds():
-            return frame
-        return None
+        return self.flow.frame_from_bounds()
 
 
 class GraphStream(TripleStream):
     physical_type = jelly.PHYSICAL_STREAM_TYPE_GRAPHS
+    default_delimited_flow_class: ClassVar = FlatQuadsFrameFlow
 
     def graph(
         self,
@@ -129,5 +176,12 @@ class GraphStream(TripleStream):
                 yield frame
         end_row = jelly.RdfStreamRow(graph_end=jelly.RdfGraphEnd())
         self.flow.append(end_row)
-        if self.flow.frame_from_bounds():
-            yield self.flow.to_stream_frame()  # type: ignore[misc]
+        if frame := self.flow.frame_from_bounds():
+            yield frame
+
+
+STREAM_DISPATCH: dict[jelly.PhysicalStreamType, type[Stream]] = {
+    jelly.PHYSICAL_STREAM_TYPE_TRIPLES: TripleStream,
+    jelly.PHYSICAL_STREAM_TYPE_QUADS: QuadStream,
+    jelly.PHYSICAL_STREAM_TYPE_GRAPHS: GraphStream,
+}

pyjelly-0.2.1.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: pyjelly
+Version: 0.2.1
+Summary: Jelly-RDF implementation for Python
+Project-URL: Homepage, https://w3id.org/jelly/pyjelly
+Project-URL: Documentation, https://w3id.org/jelly/pyjelly
+Project-URL: Repository, https://github.com/Jelly-RDF/pyjelly
+Project-URL: Issues, https://github.com/Jelly-RDF/pyjelly/issues
+Project-URL: Changelog, https://github.com/Jelly-RDF/pyjelly/releases
+Author-email: "NeverBlink et al." <contact@neverblink.eu>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: Jelly,Knowledge graph,RDF,Serialization format
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: Plugins
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: File Formats
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: protobuf>=5.29.3
+Requires-Dist: typing-extensions>=4.12.2
+Provides-Extra: rdflib
+Requires-Dist: rdflib>=7.1.4; extra == 'rdflib'
+Description-Content-Type: text/markdown
+
+[![Documentation](https://img.shields.io/website?url=https%3A%2F%2Fw3id.org%2Fjelly%2Fpyjelly&label=Documentation)](https://w3id.org/jelly/pyjelly) [![PyPI – Version](https://img.shields.io/pypi/v/pyjelly)](https://pypi.org/project/pyjelly/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyjelly)](https://pypi.org/project/pyjelly/) [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![CI status](https://github.com/Jelly-RDF/pyjelly/actions/workflows/ci.yml/badge.svg)](https://github.com/Jelly-RDF/pyjelly/actions/workflows/ci.yml) [![Discord](https://img.shields.io/discord/1333391881404420179?label=Discord%20chat)](https://discord.gg/A8sN5XwVa5)
+
+# pyjelly
+
+**pyjelly** is a Python implementation of [Jelly](http://w3id.org/jelly), a high-performance binary serialization format and streaming protocol for RDF knowledge graphs.
+
+**Documentation, usage guide and more: https://w3id.org/jelly/pyjelly**
+
+## Features
+
+- **Fast reading and writing** of RDF knowledge graphs in the [Jelly format](http://w3id.org/jelly)
+- **Seamless integration with [rdflib](https://rdflib.readthedocs.io/)**
+- **Stream processing support** for large datasets or streams of many RDF graphs/datasets
+
+## Getting started
+
+To get started with pyjelly, you can install it via pip:
+
+```bash
+pip install pyjelly[rdflib]
+```
+
+To write an RDF graph to a Jelly file, you can use the following code:
+
+```python
+from rdflib import Graph
+
+g = Graph()
+g.parse("http://xmlns.com/foaf/spec/index.rdf")
+g.serialize(destination="foaf.jelly", format="jelly")
+```
+
+To read a Jelly file and convert it to an rdflib Graph, you can use:
+
+```python
+from rdflib import Graph
+
+g = Graph()
+g.parse("foaf.jelly", format="jelly")
+```
+
+**See more examples, [API reference](https://w3id.org/jelly/pyjelly/dev/api), and more in the [documentation](https://w3id.org/jelly/pyjelly).**
+
+## Contributing and support
+
+This project is being actively developed – you can stay tuned by [watching this repository](https://docs.github.com/en/account-and-profile/managing-subscriptions-and-notifications-on-github/setting-up-notifications/about-notifications#subscription-options).
+
+You can also join the **[Jelly Discord chat](https://discord.gg/A8sN5XwVa5)** to ask questions about pyjelly and to be up-to-date with the development activities.
+
+### Commercial support
+
+**[NeverBlink](https://neverblink.eu)** provides commercial support services for Jelly, including implementing custom features, system integrations, implementations for new frameworks, benchmarking, and more.
+
+## Contributing
+
+If you'd like to contribute, check out our [contributing guidelines](CONTRIBUTING.md).
+
+## License
+
+The pyjelly library is licensed under the [Apache 2.0 license](https://www.apache.org/licenses/LICENSE-2.0).
+
+----
+
+The development of the Jelly protocol, its implementations, and supporting tooling was co-funded by the European Union. **[More details](https://w3id.org/jelly/dev/licensing/projects)**.

{pyjelly-0.1.0.dist-info → pyjelly-0.2.1.dist-info}/RECORD

@@ -1,28 +1,28 @@
 pyjelly/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyjelly/errors.py,sha256=R-xRB4a9S19J9dzAL4a5MCaBwb9ev_kvphGFkQJX6ZU,332
-pyjelly/options.py,sha256=QyGLpHOyNvBSVYYtbLD2rW43gHXRY580NAA17G9dhHs,4045
+pyjelly/options.py,sha256=jYVPNdaMTh76Oqtdk8kaJwG5gv8dUjlMkW6nXWohCn4,3862
 pyjelly/_proto/grpc.proto,sha256=3PfcZWqKhUSzP_T-xT-80raUYERr_dXWd8rITzXIqek,1188
 pyjelly/_proto/patch.proto,sha256=gASUm0xDG9J1advNoq_cCsJYxudTbQaiZQBq4oW3kw4,5291
 pyjelly/_proto/rdf.proto,sha256=EKxyG421B4m0Wx5-6jjojdga_hA3jpZfF6-T3lMc0hI,12763
 pyjelly/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyjelly/integrations/rdflib/__init__.py,sha256=lpIz6iildMf5bDvj3aBqZJ7kgKFrTx_tsqSb6PkLis0,552
-pyjelly/integrations/rdflib/parse.py,sha256=k7cNSFgFXK0_4792eZ-lDRzzSqLI7DFMZmbsPD9SLyE,7474
-pyjelly/integrations/rdflib/serialize.py,sha256=YNwKBD_a4oKNktUQa092UXvmdcu9JYAJDkYRfki2p-w,3940
+pyjelly/integrations/rdflib/parse.py,sha256=ZjFQt72U64jpVSuyVHq28H9cSNISl8O4_W_HlyqtZXQ,9738
+pyjelly/integrations/rdflib/serialize.py,sha256=5M17BN5LKSR5bPX2V97AjKNRF9UKQHwj1CMreILCUE4,6044
 pyjelly/jelly/__init__.py,sha256=9kacwn8Ew_1fcgj1abz6miEz-AtUdPT2ltFWaRIE5VE,126
 pyjelly/jelly/rdf_pb2.py,sha256=L_fPtDaURFCpLIMqVdl4RwiWyVgEFOwtB4-If3MpoSg,8952
 pyjelly/jelly/rdf_pb2.pyi,sha256=-Vv2HlpUWhaKPEb0YXOTx21cIKoqoBmTY8U6HPMUcLw,11789
 pyjelly/parse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyjelly/parse/decode.py,sha256=7yfpZ4w8HeXTqWyDROsqfXSaZcCsdnYNhYoRtxRaWEs,8455
-pyjelly/parse/ioutils.py,sha256=FnQNPiDAWLk0IXxUkmVxjsVEjC1y-dBTKKk6lf224SM,2747
+pyjelly/parse/decode.py,sha256=LJHWBXqYP0Bk4_3FIxeTNXPCRVbWMU3YzFObrzvcIzE,8910
+pyjelly/parse/ioutils.py,sha256=m7Kxqw0lAhM7swFuDWPRBE3ngjkiYRVUoM2O1QOVyT4,2720
 pyjelly/parse/lookup.py,sha256=1AbdZEycLC4tRfh3fgF5hv5PrhwhdWvCUC53iHt-E4c,2193
 pyjelly/serialize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyjelly/serialize/encode.py,sha256=ev8Z7B-ptvch1Xu173lDO3JW3egW-QyzOngDfLDzKsI,6548
-pyjelly/serialize/flows.py,sha256=vezvYeYYumEH0IceebogW4QwM2d1GeOv1yASrJWTTHc,2665
+pyjelly/serialize/encode.py,sha256=U3B2VkEO3J0bABTF18rvC8FCzqsi4Xo1RqtHCMbaub0,6485
+pyjelly/serialize/flows.py,sha256=mCGJnR7UyuAPn4EArXaBt3llpZ3_iwLq90bQwRTbhpg,3933
 pyjelly/serialize/ioutils.py,sha256=2_NaadLfHO3jKR1ZV7aK6jQ09sPKBar9iLFHYwourz8,400
-pyjelly/serialize/lookup.py,sha256=vH21uzs7gvjk-Yc0hoSC3_LPsVff86YHuUhikP9djYo,4047
-pyjelly/serialize/streams.py,sha256=0csixgSnGprXhoHOoVimtoPFgt4mqU4Lgv_l6d0EW6g,4247
-pyjelly-0.1.0.dist-info/METADATA,sha256=Kh6HOcK8aLfkSyszqaKOejBbqaI1JrR1gzJ85xfWlr8,348
-pyjelly-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pyjelly-0.1.0.dist-info/entry_points.txt,sha256=kUG0p9zso7HpitdMaQaXEj_KSqgOGsL0Ky9ARbecN1g,339
-pyjelly-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyjelly-0.1.0.dist-info/RECORD,,
+pyjelly/serialize/lookup.py,sha256=h0lYFjdB6CIuN2DzAW6EE4ILJFUuto3paAK6DG1DZYg,4091
+pyjelly/serialize/streams.py,sha256=JiYHZc2YkyWuSspsLBybGimBpTOPZJSrzC8fRVYQ2p8,6117
+pyjelly-0.2.1.dist-info/METADATA,sha256=L-9nN34XpAcL3WHsLg1yZIW40DSif9iw1WC4x-sILrw,4585
+pyjelly-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyjelly-0.2.1.dist-info/entry_points.txt,sha256=kUG0p9zso7HpitdMaQaXEj_KSqgOGsL0Ky9ARbecN1g,339
+pyjelly-0.2.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyjelly-0.2.1.dist-info/RECORD,,

pyjelly-0.1.0.dist-info/METADATA

@@ -1,10 +0,0 @@
-Metadata-Version: 2.4
-Name: pyjelly
-Version: 0.1.0
-Summary: Jelly RDF implementation for Python
-Author-email: Bartosz Sławecki <bartosz@neverblink.eu>, Anastasiya Danilenka <anastasiya@neverblink.eu>
-License-File: LICENSE
-Requires-Python: >=3.9
-Requires-Dist: protobuf>=5.29.3
-Requires-Dist: rdflib>=7.1.4
-Requires-Dist: typing-extensions>=4.12.2