pyjelly 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

pyjelly/integrations/generic/generic_sink.py

@@ -4,7 +4,13 @@ from collections import deque
 from collections.abc import Generator
 from typing import IO, NamedTuple, Union
 
-DEFAULT_GRAPH_IDENTIFIER = ""
+
+class _DefaultGraph:
+    def __repr__(self) -> str:
+        return ""
+
+
+DefaultGraph = _DefaultGraph()
 
 
 class BlankNode:
@@ -19,6 +25,14 @@ class BlankNode:
     def __repr__(self) -> str:
         return f"BlankNode(identifier={self._identifier})"
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, BlankNode):
+            return self._identifier == other._identifier
+        return False
+
+    def __hash__(self) -> int:
+        return hash(self._identifier)
+
 
 class IRI:
     """Class for IRIs, storing IRI as a string."""
@@ -37,6 +51,9 @@ class IRI:
             return self._iri == other._iri
         return False
 
+    def __hash__(self) -> int:
+        return hash(self._iri)
+
 
 class Literal:
     """
@@ -69,8 +86,21 @@ class Literal:
             f"datatype={self._datatype!r})"
         )
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Literal):
+            return (
+                self._lex == other._lex
+                and self._langtag == other._langtag
+                and self._datatype == other._datatype
+            )
+        return False
+
+    def __hash__(self) -> int:
+        return hash((self._lex, self._langtag, self._datatype))
+
 
-Node = Union[BlankNode, IRI, Literal, "Triple", str]
+Node = Union[BlankNode, IRI, Literal, "Triple"]
+GraphName = Union[Node, _DefaultGraph]
 
 
 TRIPLE_ARITY = 3
@@ -90,7 +120,7 @@ class Quad(NamedTuple):
     s: Node
     p: Node
     o: Node
-    g: Node
+    g: GraphName
 
 
 class Prefix(NamedTuple):
@@ -103,7 +133,7 @@ class Prefix(NamedTuple):
 class GenericStatementSink:
     _store: deque[Triple | Quad]
 
-    def __init__(self, identifier: Node = DEFAULT_GRAPH_IDENTIFIER) -> None:
+    def __init__(self, identifier: GraphName = DefaultGraph) -> None:
         """
         Initialize statements storage, namespaces dictionary, and parser.
 
@@ -112,7 +142,7 @@ class GenericStatementSink:
 
         Args:
             identifier (str, optional): Identifier for a sink.
-                Defaults to DEFAULT_GRAPH_IDENTIFIER.
+                Defaults to DefaultGraph.
 
         """
         self._store: deque[Triple | Quad] = deque()
@@ -136,7 +166,7 @@ class GenericStatementSink:
         yield from self._namespaces.items()
 
     @property
-    def identifier(self) -> Node:
+    def identifier(self) -> GraphName:
         return self._identifier
 
     @property

pyjelly/integrations/generic/parse.py

@@ -10,7 +10,9 @@ from pyjelly.errors import JellyConformanceError
 from pyjelly.integrations.generic.generic_sink import (
     IRI,
     BlankNode,
+    DefaultGraph,
     GenericStatementSink,
+    GraphName,
     Literal,
     Prefix,
     Quad,
@@ -44,8 +46,8 @@ class GenericStatementSinkAdapter(Adapter):
         return BlankNode(bnode)
 
     @override
-    def default_graph(self) -> str:
-        return ""
+    def default_graph(self) -> GraphName:
+        return DefaultGraph
 
     @override
     def literal(
@@ -122,7 +124,7 @@ class GenericGraphsAdapter(GenericQuadsBaseAdapter):
 
     """
 
-    _graph_id: str | None
+    _graph_id: GraphName | None
 
     def __init__(
         self,
@@ -138,7 +140,7 @@ class GenericGraphsAdapter(GenericQuadsBaseAdapter):
             raise JellyConformanceError(msg)
 
     @override
-    def graph_start(self, graph_id: str) -> None:
+    def graph_start(self, graph_id: GraphName) -> None:
         self._graph_id = graph_id
 
     @override
@@ -206,6 +208,8 @@ def parse_quads_stream(
 def parse_jelly_grouped(
     inp: IO[bytes],
     sink_factory: Callable[[], GenericStatementSink] = lambda: GenericStatementSink(),
+    *,
+    logical_type_strict: bool = False,
 ) -> Generator[GenericStatementSink]:
     """
     Take a jelly file and return generators of generic statements sinks.
@@ -215,7 +219,10 @@ def parse_jelly_grouped(
     Args:
         inp (IO[bytes]): input jelly buffered binary stream
         sink_factory (Callable): lambda to construct a statement sink.
-            By default creates an empty in-memory GenericStatementSink.
+            By default, creates an empty in-memory GenericStatementSink.
+        logical_type_strict (bool): If True, validate the *logical* type
+            in stream options and require a grouped logical type.
+            Otherwise, only the physical type is used to route parsing.
 
     Raises:
         NotImplementedError: is raised if a physical type is not implemented
@@ -226,6 +233,26 @@ def parse_jelly_grouped(
 
     """
     options, frames = get_options_and_frames(inp)
+
+    st = getattr(options, "stream_types", None)
+    if logical_type_strict and (
+        st is None
+        or st.logical_type == jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED
+        or st.flat
+    ):
+        lt_name = (
+            "UNSPECIFIED"
+            if st is None
+            else jelly.LogicalStreamType.Name(st.logical_type)
+        )
+
+        msg = (
+            "strict logical type check requires options.stream_types"
+            if st is None
+            else f"expected GROUPED logical type, got {lt_name}"
+        )
+        raise JellyConformanceError(msg)
+
     if options.stream_types.physical_type == jelly.PHYSICAL_STREAM_TYPE_TRIPLES:
         for graph in parse_triples_stream(
             frames=frames,
@@ -297,6 +324,8 @@ def parse_jelly_flat(
     inp: IO[bytes],
     frames: Iterable[jelly.RdfStreamFrame] | None = None,
     options: ParserOptions | None = None,
+    *,
+    logical_type_strict: bool = False,
 ) -> Generator[Statement | Prefix]:
     """
     Parse jelly file with FLAT logical type into a Generator of stream events.
@@ -307,6 +336,9 @@ def parse_jelly_flat(
             jelly frames if read before.
         options (ParserOptions | None): stream options
             if read before.
+        logical_type_strict (bool): If True, validate the *logical* type
+            in stream options and require FLAT (TRIPLES/QUADS).
+            Otherwise, only the physical type is used to route parsing.
 
     Raises:
         NotImplementedError: if physical type is not supported
@@ -315,9 +347,24 @@ def parse_jelly_flat(
         Generator[Statement | Prefix]: Generator of stream events
 
     """
-    if not frames or not options:
+    if frames is None or options is None:
         options, frames = get_options_and_frames(inp)
 
+    st = getattr(options, "stream_types", None)
+    if logical_type_strict and (st is None or not st.flat):
+        lt_name = (
+            "UNSPECIFIED"
+            if st is None
+            else jelly.LogicalStreamType.Name(st.logical_type)
+        )
+
+        msg = (
+            "strict logical type check requires options.stream_types"
+            if st is None
+            else f"expected FLAT logical type (TRIPLES/QUADS), got {lt_name}"
+        )
+        raise JellyConformanceError(msg)
+
     if options.stream_types.physical_type == jelly.PHYSICAL_STREAM_TYPE_TRIPLES:
         for triples in parse_triples_stream(frames=frames, options=options):
             yield from triples

pyjelly/integrations/generic/serialize.py

@@ -5,19 +5,20 @@ from collections.abc import Generator
 from functools import singledispatch
 from typing import Any, IO
 from itertools import chain
+from pyjelly.options import StreamParameters
 from pyjelly.integrations.generic.generic_sink import (
     GenericStatementSink,
     Quad,
     Triple,
-    DEFAULT_GRAPH_IDENTIFIER,
+    DefaultGraph,
+    GraphName,
     IRI,
     BlankNode,
     Literal,
-    Node,
 )
 
 from pyjelly import jelly
-from pyjelly.serialize.encode import RowsAndTerm, Slot, TermEncoder
+from pyjelly.serialize.encode import Rows, Slot, TermEncoder, HasGraph, Statement
 from pyjelly.serialize.ioutils import write_delimited
 from pyjelly.serialize.streams import (
     GraphStream,
@@ -31,38 +32,75 @@ QUAD_ARITY = 4
 
 
 class GenericSinkTermEncoder(TermEncoder):
-    def encode_any(self, term: object, slot: Slot) -> RowsAndTerm:
+    def encode_spo(self, term: object, slot: Slot, statement: Statement) -> Rows:
         """
         Encode term based on its GenericSink object.
 
         Args:
             term (object): term to encode
             slot (Slot): its place in statement.
+            statement (Statement): Triple/Quad/GraphStart message to fill with terms.
 
         Returns:
-            RowsAndTerm: encoded extra rows and a jelly term to encode
+            Rows: encoded extra rows
 
         """
-        if slot is Slot.graph and term == DEFAULT_GRAPH_IDENTIFIER:
-            return self.encode_default_graph()
-
         if isinstance(term, IRI):
-            return self.encode_iri(term._iri)
+            iri = self.get_iri_field(statement, slot)
+            return self.encode_iri(term._iri, iri)
 
         if isinstance(term, Literal):
+            literal = self.get_literal_field(statement, slot)
             return self.encode_literal(
                 lex=term._lex,
                 language=term._langtag,
                 datatype=term._datatype,
+                literal=literal,
             )
 
         if isinstance(term, BlankNode):
-            return self.encode_bnode(term._identifier)
+            self.set_bnode_field(
+                statement,
+                slot,
+                term._identifier,
+            )
+            return ()
 
         if isinstance(term, Triple):
-            return self.encode_quoted_triple(term)
+            quoted_statement = self.get_triple_field(statement, slot)
+            return self.encode_quoted_triple(term, quoted_statement)
+
+        return super().encode_spo(term, slot, statement)  # error if not handled
 
-        return super().encode_any(term, slot)  # error if not handled
+    def encode_graph(self, term: object, statement: HasGraph) -> Rows:
+        """
+        Encode graph term based on its GenericSink object.
+
+        Args:
+            term (object): term to encode
+            statement (HasGraph): Quad/GraphStart message to fill g_{} in.
+
+        Returns:
+            Rows: encoded extra rows
+
+        """
+        if term == DefaultGraph:
+            return self.encode_default_graph(statement.g_default_graph)
+        if isinstance(term, IRI):
+            return self.encode_iri(term._iri, statement.g_iri)
+
+        if isinstance(term, Literal):
+            return self.encode_literal(
+                lex=term._lex,
+                language=term._langtag,
+                datatype=term._datatype,
+                literal=statement.g_literal,
+            )
+
+        if isinstance(term, BlankNode):
+            statement.g_bnode = term._identifier
+            return ()
+        return super().encode_graph(term, statement)  # error if not handled
 
 
 def namespace_declarations(store: GenericStatementSink, stream: Stream) -> None:
@@ -210,7 +248,7 @@ def split_to_graphs(data: Generator[Quad]) -> Generator[GenericStatementSink]:
         each having triples in store and identifier set.
 
     """
-    current_g: Node | None = None
+    current_g: GraphName | None = None
     current_sink: GenericStatementSink | None = None
     for statement in data:
         if current_g != statement.g:
@@ -234,7 +272,10 @@ def guess_options(sink: GenericStatementSink) -> SerializerOptions:
         if sink.is_triples_sink
         else jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS
     )
-    return SerializerOptions(logical_type=logical_type)
+    # Generic sink supports both RDF-star and generalized statements by default
+    # as it can handle any term types including quoted triples and generalized RDF terms
+    params = StreamParameters(generalized_statements=True, rdf_star=True)
+    return SerializerOptions(logical_type=logical_type, params=params)
 
 
 def guess_stream(options: SerializerOptions, sink: GenericStatementSink) -> Stream:

pyjelly/integrations/rdflib/parse.py

@@ -313,6 +313,8 @@ def parse_jelly_grouped(
     inp: IO[bytes],
     graph_factory: Callable[[], Graph] = lambda: Graph(),
     dataset_factory: Callable[[], Dataset] = lambda: Dataset(),
+    *,
+    logical_type_strict: bool = False,
 ) -> Generator[Graph] | Generator[Dataset]:
     """
     Take jelly file and return generators based on the detected physical type.
@@ -327,6 +329,11 @@ def parse_jelly_grouped(
         dataset_factory (Callable): lambda to construct a Dataset.
             By default creates an empty in-memory Dataset,
             but you can pass something else here.
+        logical_type_strict (bool): If True, validate the *logical* type in
+            stream options and require a grouped logical type. Otherwise, only the
+            physical type is used to route parsing.
+
+
 
     Raises:
         NotImplementedError: is raised if a physical type is not implemented
@@ -337,6 +344,26 @@ def parse_jelly_grouped(
 
     """
     options, frames = get_options_and_frames(inp)
+
+    st = getattr(options, "stream_types", None)
+    if logical_type_strict and (
+        st is None
+        or st.logical_type == jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED
+        or st.flat
+    ):
+        lt_name = (
+            "UNSPECIFIED"
+            if st is None
+            else jelly.LogicalStreamType.Name(st.logical_type)
+        )
+
+        msg = (
+            "strict logical type check requires options.stream_types"
+            if st is None
+            else f"expected GROUPED logical type, got {lt_name}"
+        )
+        raise JellyConformanceError(msg)
+
     if options.stream_types.physical_type == jelly.PHYSICAL_STREAM_TYPE_TRIPLES:
         for graph in parse_triples_stream(
             frames=frames,
@@ -424,6 +451,8 @@ def parse_jelly_flat(
     inp: IO[bytes],
     frames: Iterable[jelly.RdfStreamFrame] | None = None,
     options: ParserOptions | None = None,
+    *,
+    logical_type_strict: bool = False,
 ) -> Generator[Statement | Prefix]:
     """
     Parse jelly file with FLAT logical type into a Generator of stream events.
@@ -434,6 +463,10 @@ def parse_jelly_flat(
             jelly frames if read before.
         options (ParserOptions | None): stream options
             if read before.
+        logical_type_strict (bool): If True, validate the *logical* type in
+            stream options and require FLAT_(TRIPLES|QUADS). Otherwise, only the
+            physical type is used to route parsing.
+
 
     Raises:
         NotImplementedError: if physical type is not supported
@@ -442,9 +475,23 @@ def parse_jelly_flat(
         Generator[Statement | Prefix]: Generator of stream events
 
     """
-    if not frames or not options:
+    if frames is None or options is None:
         options, frames = get_options_and_frames(inp)
 
+    st = getattr(options, "stream_types", None)
+    if logical_type_strict and (st is None or not st.flat):
+        lt_name = (
+            "UNSPECIFIED"
+            if st is None
+            else jelly.LogicalStreamType.Name(st.logical_type)
+        )
+        msg = (
+            "strict logical type check requires options.stream_types"
+            if st is None
+            else f"expected FLAT logical type (TRIPLES/QUADS), got {lt_name}"
+        )
+        raise JellyConformanceError(msg)
+
     if options.stream_types.physical_type == jelly.PHYSICAL_STREAM_TYPE_TRIPLES:
         for triples in parse_triples_stream(frames=frames, options=options):
             yield from triples

pyjelly/integrations/rdflib/serialize.py

@@ -7,6 +7,7 @@ from typing import Any, IO
 from typing_extensions import override
 from itertools import chain
 from pyjelly.integrations.rdflib.parse import Quad, Triple
+from pyjelly.options import StreamParameters
 
 import rdflib
 from rdflib import Graph
@@ -14,7 +15,7 @@ from rdflib.graph import DATASET_DEFAULT_GRAPH_ID, Dataset, QuotedGraph
 from rdflib.serializer import Serializer as RDFLibSerializer
 
 from pyjelly import jelly
-from pyjelly.serialize.encode import RowsAndTerm, Slot, TermEncoder
+from pyjelly.serialize.encode import Rows, Slot, TermEncoder, Statement, HasGraph
 from pyjelly.serialize.ioutils import write_delimited, write_single
 from pyjelly.serialize.streams import (
     GraphStream,
@@ -28,37 +29,62 @@ QUAD_ARITY = 4
 
 
 class RDFLibTermEncoder(TermEncoder):
-    def encode_any(self, term: object, slot: Slot) -> RowsAndTerm:
+    def encode_spo(self, term: object, slot: Slot, statement: Statement) -> Rows:
         """
-        Encode term based on its RDFLib object.
+        Encode s/p/o term based on its RDFLib object.
 
         Args:
             term (object): term to encode
             slot (Slot): its place in statement.
+            statement (Statement): Triple/Quad message to fill with s/p/o terms.
 
         Returns:
-            RowsAndTerm: encoded extra rows and a jelly term to encode
+            Rows: encoded extra rows
 
         """
-        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)
+            iri = self.get_iri_field(statement, slot)
+            return self.encode_iri(term, iri)
 
         if isinstance(term, rdflib.Literal):
+            literal = self.get_literal_field(statement, slot)
             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),
+                literal=literal,
             )
 
         if isinstance(term, rdflib.BNode):
-            return self.encode_bnode(str(term))
+            self.set_bnode_field(statement, slot, str(term))
+            return ()
+
+        return super().encode_spo(term, slot, statement)  # error if not handled
+
+    def encode_graph(self, term: object, statement: HasGraph) -> Rows:
+        """
+        Encode graph name term based on its RDFLib object.
+
+        Args:
+            term (object): term to encode
+            statement (HasGraph): Quad/GraphStart message to fill g_{} in.
 
-        return super().encode_any(term, slot)  # error if not handled
+        Returns:
+            Rows: encoded extra rows
+
+        """
+        if term == DATASET_DEFAULT_GRAPH_ID:
+            return self.encode_default_graph(statement.g_default_graph)
+
+        if isinstance(term, rdflib.URIRef):
+            return self.encode_iri(term, statement.g_iri)
+
+        if isinstance(term, rdflib.BNode):
+            statement.g_bnode = str(term)
+            return ()
+        return super().encode_graph(term, statement)  # error if not handled
 
 
 def namespace_declarations(store: Graph, stream: Stream) -> None:
@@ -205,7 +231,10 @@ def guess_options(sink: Graph | Dataset) -> SerializerOptions:
         if isinstance(sink, Dataset)
         else jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES
     )
-    return SerializerOptions(logical_type=logical_type)
+    # RDFLib doesn't support RDF-star and generalized statements by default
+    # as it requires specific handling for quoted triples and non-standard RDF terms
+    params = StreamParameters(generalized_statements=False, rdf_star=False)
+    return SerializerOptions(logical_type=logical_type, params=params)
 
 
 def guess_stream(options: SerializerOptions, sink: Graph | Dataset) -> Stream:

pyjelly/parse/decode.py

@@ -7,7 +7,7 @@ from typing import Any, ClassVar, NamedTuple
 from typing_extensions import Never
 
 from pyjelly import jelly
-from pyjelly.options import LookupPreset, StreamParameters, StreamTypes
+from pyjelly.options import MAX_VERSION, LookupPreset, StreamParameters, StreamTypes
 from pyjelly.parse.lookup import LookupDecoder
 
 
@@ -54,6 +54,9 @@ def options_from_frame(
     """
     row = frame.rows[0]
     options = row.options
+    nd = getattr(options, "namespace_declarations", False) or (
+        options.version >= MAX_VERSION
+    )
     return ParserOptions(
         stream_types=StreamTypes(
             physical_type=options.physical_type,
@@ -70,6 +73,7 @@ def options_from_frame(
             rdf_star=options.rdf_star,
             version=options.version,
             delimited=delimited,
+            namespace_declarations=nd,
         ),
     )
 

pyjelly/parse/ioutils.py

@@ -1,3 +1,4 @@
+import io
 import os
 from collections.abc import Generator, Iterator
 from itertools import chain
@@ -48,7 +49,7 @@ def delimited_jelly_hint(header: bytes) -> bool:
     False
     """
     magic = 0x0A
-    return len(header) == 3 and (  # noqa: PLR2004
+    return len(header) >= 3 and (  # noqa: PLR2004
         header[0] != magic or (header[1] == magic and header[2] != magic)
     )
 
@@ -77,8 +78,15 @@ def get_options_and_frames(
             stream types, lookup presets and other stream options
 
     """
-    is_delimited = delimited_jelly_hint(bytes_read := inp.read(3))
-    inp.seek(-len(bytes_read), os.SEEK_CUR)
+    if not inp.seekable():
+        # Input may not be seekable (e.g. a network stream) -- then we need to buffer
+        # it to determine if it's delimited.
+        # See also: https://github.com/Jelly-RDF/pyjelly/issues/298
+        inp = io.BufferedReader(inp)  # type: ignore[arg-type]
+        is_delimited = delimited_jelly_hint(inp.peek(3))
+    else:
+        is_delimited = delimited_jelly_hint(bytes_read := inp.read(3))
+        inp.seek(-len(bytes_read), os.SEEK_CUR)
 
     if is_delimited:
         first_frame = None

pyjelly/serialize/encode.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from collections.abc import Iterable, Sequence
-from enum import Enum
-from typing import Any, ClassVar, TypeVar
+from collections.abc import Iterable, Iterator, Sequence
+from enum import IntEnum
+from typing import TypeVar, Union
 from typing_extensions import TypeAlias
 
 from pyjelly import jelly, options
@@ -31,20 +31,15 @@ def split_iri(iri_string: str) -> tuple[str, str]:
 
 
 T = TypeVar("T")
-RowsAnd: TypeAlias = tuple[Sequence[jelly.RdfStreamRow], T]
-RowsAndTerm: TypeAlias = "RowsAnd[jelly.RdfIri | jelly.RdfLiteral | str | \
-    jelly.RdfDefaultGraph | jelly.RdfTriple]"
+Rows: TypeAlias = Sequence[jelly.RdfStreamRow]
+Statement: TypeAlias = Union[jelly.RdfQuad, jelly.RdfTriple]
+HasGraph: TypeAlias = Union[jelly.RdfQuad, jelly.RdfGraphStart]
+Terms: TypeAlias = Union[
+    jelly.RdfIri, jelly.RdfLiteral, str, jelly.RdfDefaultGraph, jelly.RdfTriple
+]
 
 
 class TermEncoder:
-    TERM_ONEOF_NAMES: ClassVar = {
-        jelly.RdfIri: "iri",
-        jelly.RdfLiteral: "literal",
-        str: "bnode",
-        jelly.RdfDefaultGraph: "default_graph",
-        jelly.RdfTriple: "triple_term",
-    }
-
     def __init__(
         self,
         lookup_preset: options.LookupPreset | None = None,
@@ -56,15 +51,16 @@ class TermEncoder:
         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]:
+    def encode_iri_indices(self, iri_string: str) -> tuple[Rows, int, int]:
         """
-        Encode iri.
+        Encode lookup indices for IRI.
 
         Args:
             iri_string (str): full iri in string format.
 
         Returns:
-            RowsAnd[jelly.RdfIri]: extra rows and protobuf RdfIri message.
+            tuple[Rows, int, int]: additional rows (if any) and
+                indices in prefix and name tables.
 
         """
         prefix, name = split_iri(iri_string)
@@ -87,31 +83,35 @@ class TermEncoder:
 
         prefix_index = self.prefixes.encode_prefix_term_index(prefix)
         name_index = self.names.encode_name_term_index(name)
-        return term_rows, jelly.RdfIri(prefix_id=prefix_index, name_id=name_index)
+        return term_rows, prefix_index, name_index
 
-    def encode_default_graph(self) -> RowsAnd[jelly.RdfDefaultGraph]:
+    def encode_iri(self, iri_string: str, iri: jelly.RdfIri) -> Rows:
         """
-        Encode default graph.
+        Encode iri.
+
+        Args:
+            iri_string (str): full iri in string format.
+            iri (jelly.RdfIri): iri to fill
 
         Returns:
-            RowsAnd[jelly.RdfDefaultGraph]: empty extra rows and
-                default graph message.
+            Rows: extra rows for prefix and name tables, if any.
 
         """
-        return (), jelly.RdfDefaultGraph()
+        term_rows, prefix_index, name_index = self.encode_iri_indices(iri_string)
+        iri.prefix_id = prefix_index
+        iri.name_id = name_index
+        return term_rows
 
-    def encode_bnode(self, bnode: str) -> RowsAnd[str]:
+    def encode_default_graph(self, g_default_graph: jelly.RdfDefaultGraph) -> Rows:
         """
-        Encode blank node (BN).
-
-        Args:
-            bnode (str): BN internal identifier in string format.
+        Encode default graph.
 
         Returns:
-            RowsAnd[str]: empty extra rows and original BN string.
+            Rows: empty extra rows (for API consistency)
 
         """
-        return (), bnode
+        g_default_graph.CopyFrom(jelly.RdfDefaultGraph())
+        return ()
 
     def encode_literal(
         self,
@@ -119,7 +119,8 @@ class TermEncoder:
         lex: str,
         language: str | None = None,
         datatype: str | None = None,
-    ) -> RowsAnd[jelly.RdfLiteral]:
+        literal: jelly.RdfLiteral,
+    ) -> Rows:
         """
         Encode literal.
 
@@ -128,14 +129,14 @@ class TermEncoder:
             language (str | None, optional): langtag. Defaults to None.
             datatype (str | None, optional): data type if
             it is a typed literal. Defaults to None.
+            literal (jelly.RdfLiteral): literal to fill.
 
         Raises:
             JellyConformanceError: if datatype specified while
                 datatable is not used.
 
         Returns:
-            RowsAnd[jelly.RdfLiteral]: extra rows (i.e., datatype entries)
-                and RdfLiteral message.
+            Rows: extra rows (i.e., datatype entries).
 
         """
         datatype_id = None
@@ -157,13 +158,16 @@ class TermEncoder:
 
             datatype_id = self.datatypes.encode_datatype_term_index(datatype)
 
-        return term_rows, jelly.RdfLiteral(
-            lex=lex,
-            langtag=language,
-            datatype=datatype_id,
-        )
+        literal.lex = lex
+        if language:
+            literal.langtag = language
+        if datatype_id:
+            literal.datatype = datatype_id
+        return term_rows
 
-    def encode_quoted_triple(self, terms: Iterable[object]) -> RowsAndTerm:
+    def encode_quoted_triple(
+        self, terms: Iterable[object], quoted_statement: jelly.RdfTriple
+    ) -> Rows:
         """
         Encode a quoted triple.
 
@@ -173,75 +177,116 @@ class TermEncoder:
 
         Args:
             terms (Iterable[object]): triple terms to encode.
+            quoted_statement (jelly.RdfTriple): quoted triple to fill.
 
         Returns:
-            RowsAndTerm: additional stream rows with preceeding
-                information (prefixes, names, datatypes rows, if any)
-                and the encoded triple row.
+            Rows: additional stream rows with preceeding
+                information (prefixes, names, datatypes rows, if any).
 
         """
-        statement: dict[str, Any] = {}
         rows: list[jelly.RdfStreamRow] = []
-        for slot, term in zip(Slot, terms):
-            extra_rows, value = self.encode_any(term, slot)
-            oneof = self.TERM_ONEOF_NAMES[type(value)]
-            rows.extend(extra_rows)
-            field = f"{slot}_{oneof}"
-            statement[field] = value
-        return rows, jelly.RdfTriple(**statement)
-
-    def encode_any(self, term: object, slot: Slot) -> RowsAndTerm:
+        terms = iter(terms)
+        extra_rows = self.encode_spo(next(terms), Slot.subject, quoted_statement)
+        rows.extend(extra_rows)
+        extra_rows = self.encode_spo(next(terms), Slot.predicate, quoted_statement)
+        rows.extend(extra_rows)
+        extra_rows = self.encode_spo(next(terms), Slot.object, quoted_statement)
+        rows.extend(extra_rows)
+        return rows
+
+    def encode_spo(self, term: object, slot: Slot, statement: Statement) -> Rows:
         msg = f"unsupported term type: {type(term)}"
         raise NotImplementedError(msg)
 
+    def encode_graph(self, term: object, statement: HasGraph) -> Rows:
+        msg = f"unsupported term type: {type(term)}"
+        raise NotImplementedError(msg)
+
+    def get_iri_field(self, statement: Statement, slot: Slot) -> jelly.RdfIri:
+        """Get IRI field directly based on slot."""
+        if slot == Slot.subject:
+            return statement.s_iri
+        if slot == Slot.predicate:
+            return statement.p_iri
+        return statement.o_iri
+
+    def get_literal_field(self, statement: Statement, slot: Slot) -> jelly.RdfLiteral:
+        """Get literal field directly based on slot."""
+        if slot == Slot.subject:
+            return statement.s_literal
+        if slot == Slot.predicate:
+            return statement.p_literal
+        return statement.o_literal
+
+    def set_bnode_field(
+        self, statement: Statement, slot: Slot, identifier: str
+    ) -> None:
+        """Set bnode field directly based on slot."""
+        if slot == Slot.subject:
+            statement.s_bnode = identifier
+        elif slot == Slot.predicate:
+            statement.p_bnode = identifier
+        else:
+            statement.o_bnode = identifier
 
-class Slot(str, Enum):
-    """Slots for encoding RDF terms."""
+    def get_triple_field(self, statement: Statement, slot: Slot) -> jelly.RdfTriple:
+        """Get triple term field directly based on slot."""
+        if slot == Slot.subject:
+            return statement.s_triple_term
+        if slot == Slot.predicate:
+            return statement.p_triple_term
+        return statement.o_triple_term
 
-    subject = "s"
-    predicate = "p"
-    object = "o"
-    graph = "g"
 
-    def __str__(self) -> str:
-        return self.value
+class Slot(IntEnum):
+    subject = 0
+    predicate = 1
+    object = 2
+    graph = 3
 
 
-def encode_statement(
-    terms: Iterable[object],
+def encode_spo(
+    terms: Iterator[object],
     term_encoder: TermEncoder,
-    repeated_terms: dict[Slot, object],
-) -> tuple[list[jelly.RdfStreamRow], dict[str, Any]]:
+    repeated_terms: list[object | None],
+    statement: Statement,
+) -> list[jelly.RdfStreamRow]:
     """
-    Encode a statement.
+    Encode the s/p/o of a statement.
 
     Args:
-        terms (Iterable[object]): original terms to encode
+        terms (Iterator[object]): iterator for original terms to encode
         term_encoder (TermEncoder): encoder with lookup tables
-        repeated_terms (dict[Slot, object]): dictionary of repeated terms.
+        repeated_terms (list[object | None): list of repeated terms.
+        statement (Statement): Triple/Quad to fill.
 
     Returns:
-        tuple[list[jelly.RdfStreamRow], dict[str, Any]]:
-            extra rows to append and jelly terms.
+        list[jelly.RdfStreamRow] extra rows to append.
 
     """
-    statement: dict[str, object] = {}
     rows: list[jelly.RdfStreamRow] = []
-    for slot, term in zip(Slot, terms):
-        if repeated_terms[slot] != term:
-            extra_rows, value = term_encoder.encode_any(term, slot)
-            oneof = term_encoder.TERM_ONEOF_NAMES[type(value)]
-            rows.extend(extra_rows)
-            field = f"{slot}_{oneof}"
-            statement[field] = value
-            repeated_terms[slot] = term
-    return rows, statement
+    s = next(terms)
+    if repeated_terms[Slot.subject] != s:
+        extra_rows = term_encoder.encode_spo(s, Slot.subject, statement)
+        rows.extend(extra_rows)
+        repeated_terms[Slot.subject] = s
+    p = next(terms)
+    if repeated_terms[Slot.predicate] != p:
+        extra_rows = term_encoder.encode_spo(p, Slot.predicate, statement)
+        rows.extend(extra_rows)
+        repeated_terms[Slot.predicate] = p
+    o = next(terms)
+    if repeated_terms[Slot.object] != o:
+        extra_rows = term_encoder.encode_spo(o, Slot.object, statement)
+        rows.extend(extra_rows)
+        repeated_terms[Slot.object] = o
+    return rows
 
 
 def encode_triple(
     terms: Iterable[object],
     term_encoder: TermEncoder,
-    repeated_terms: dict[Slot, object],
+    repeated_terms: list[object | None],
 ) -> list[jelly.RdfStreamRow]:
     """
     Encode one triple.
@@ -249,14 +294,16 @@ def encode_triple(
     Args:
         terms (Iterable[object]): original terms to encode
         term_encoder (TermEncoder): current encoder with lookup tables
-        repeated_terms (dict[Slot, object]): dictionary of repeated terms.
+        repeated_terms (list[object | None]): list of repeated terms.
 
     Returns:
         list[jelly.RdfStreamRow]: list of rows to add to the current flow.
 
     """
-    rows, statement = encode_statement(terms, term_encoder, repeated_terms)
-    row = jelly.RdfStreamRow(triple=jelly.RdfTriple(**statement))
+    triple = jelly.RdfTriple()
+    terms = iter(terms)
+    rows = encode_spo(terms, term_encoder, repeated_terms, triple)
+    row = jelly.RdfStreamRow(triple=triple)
     rows.append(row)
     return rows
 
@@ -264,7 +311,7 @@ def encode_triple(
 def encode_quad(
     terms: Iterable[object],
     term_encoder: TermEncoder,
-    repeated_terms: dict[Slot, object],
+    repeated_terms: list[object | None],
 ) -> list[jelly.RdfStreamRow]:
     """
     Encode one quad.
@@ -272,14 +319,21 @@ def encode_quad(
     Args:
         terms (Iterable[object]): original terms to encode
         term_encoder (TermEncoder): current encoder with lookup tables
-        repeated_terms (dict[Slot, object]): dictionary of repeated terms.
+        repeated_terms (list[object | None]): list of repeated terms.
 
     Returns:
         list[jelly.RdfStreamRow]: list of messages to append to current flow.
 
     """
-    rows, statement = encode_statement(terms, term_encoder, repeated_terms)
-    row = jelly.RdfStreamRow(quad=jelly.RdfQuad(**statement))
+    terms = iter(terms)
+    quad = jelly.RdfQuad()
+    rows = encode_spo(terms, term_encoder, repeated_terms, quad)
+    g = next(terms)
+    if repeated_terms[Slot.graph] != g:
+        extra_rows = term_encoder.encode_graph(g, quad)
+        rows.extend(extra_rows)
+        repeated_terms[Slot.graph] = g
+    row = jelly.RdfStreamRow(quad=quad)
     rows.append(row)
     return rows
 
@@ -301,7 +355,8 @@ def encode_namespace_declaration(
         list[jelly.RdfStreamRow]: list of messages to append to current flow.
 
     """
-    [*rows], iri = term_encoder.encode_iri(value)
+    iri = jelly.RdfIri()
+    [*rows] = term_encoder.encode_iri(value, iri=iri)
     declaration = jelly.RdfNamespaceDeclaration(name=name, value=iri)
     row = jelly.RdfStreamRow(namespace=declaration)
     rows.append(row)

pyjelly/serialize/streams.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Generator, Iterable
 from dataclasses import dataclass, field
-from typing import Any, ClassVar
+from typing import ClassVar
 
 from pyjelly import jelly
 from pyjelly.options import LookupPreset, StreamParameters, StreamTypes
@@ -37,6 +37,7 @@ class SerializerOptions:
 class Stream:
     physical_type: ClassVar[jelly.PhysicalStreamType]
     default_delimited_flow_class: ClassVar[type[BoundedFrameFlow]]
+    repeated_terms: list[object | None]
 
     def __init__(
         self,
@@ -52,7 +53,7 @@ class Stream:
         if flow is None:
             flow = self.infer_flow()
         self.flow = flow
-        self.repeated_terms = dict.fromkeys(Slot)
+        self.repeated_terms = [None] * len(Slot)
         self.enrolled = False
         self.stream_types = StreamTypes(
             physical_type=self.physical_type,
@@ -249,10 +250,9 @@ class GraphStream(TripleStream):
             Generator[jelly.RdfStreamFrame]: jelly frames.
 
         """
-        [*graph_rows], graph_node = self.encoder.encode_any(graph_id, Slot.graph)
-        kw_name = f"{Slot.graph}_{self.encoder.TERM_ONEOF_NAMES[type(graph_node)]}"
-        kws: dict[Any, Any] = {kw_name: graph_node}
-        start_row = jelly.RdfStreamRow(graph_start=jelly.RdfGraphStart(**kws))
+        graph_start = jelly.RdfGraphStart()
+        [*graph_rows] = self.encoder.encode_graph(graph_id, graph_start)
+        start_row = jelly.RdfStreamRow(graph_start=graph_start)
         graph_rows.append(start_row)
         self.flow.extend(graph_rows)
         for triple in graph:

{pyjelly-0.5.3.dist-info → pyjelly-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyjelly
-Version: 0.5.3
+Version: 0.6.1
 Summary: Jelly-RDF implementation for Python
 Project-URL: Homepage, https://w3id.org/jelly/pyjelly
 Project-URL: Documentation, https://w3id.org/jelly/pyjelly

{pyjelly-0.5.3.dist-info → pyjelly-0.6.1.dist-info}/RECORD

@@ -6,27 +6,27 @@ pyjelly/_proto/patch.proto,sha256=gASUm0xDG9J1advNoq_cCsJYxudTbQaiZQBq4oW3kw4,52
 pyjelly/_proto/rdf.proto,sha256=EKxyG421B4m0Wx5-6jjojdga_hA3jpZfF6-T3lMc0hI,12763
 pyjelly/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyjelly/integrations/generic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyjelly/integrations/generic/generic_sink.py,sha256=jOpBv3GkAT4_RbdFE-8gBcsUBDuDpShj1AgXUYM-hr0,4169
-pyjelly/integrations/generic/parse.py,sha256=BLavZP-CgstDfQtrMzhsn1OnGQQBe-DNmmxqCWvdAmc,9564
-pyjelly/integrations/generic/serialize.py,sha256=F3giZpPrMAuIL9LHm58e1u_9Y-wwMy9rPUmpxb3OVTY,10893
+pyjelly/integrations/generic/generic_sink.py,sha256=-53sANwfCT3ygb6FrvFSa0Ri8Hb63Cpi8AfR7igJgcQ,4949
+pyjelly/integrations/generic/parse.py,sha256=ScbBUo8kc4ztJjD9Nr7YdfSFZmNgWmIxmizBvXpy9kw,11212
+pyjelly/integrations/generic/serialize.py,sha256=eJYHTtBKvLl82DMPZBn0Ojp1sQrhmTttY9KPuYwYnl4,12494
 pyjelly/integrations/rdflib/__init__.py,sha256=lpIz6iildMf5bDvj3aBqZJ7kgKFrTx_tsqSb6PkLis0,552
-pyjelly/integrations/rdflib/parse.py,sha256=73i4BAI72ZfZycNRlAPboRcpgPAS7XFG5Yesnfe7yME,13718
-pyjelly/integrations/rdflib/serialize.py,sha256=LwWeBZDoyQL4mC6wta2TnW_1ys3_kqxmAFkAoJMJnOw,11675
+pyjelly/integrations/rdflib/parse.py,sha256=J5WsuAFXc2MNOaaMAknxQRub89RhcOWVWarcl5jb3PI,15306
+pyjelly/integrations/rdflib/serialize.py,sha256=G6W-NpaIk4nDb50D_g-S2WcDqG9FlXfUOer0UYKYIyA,12886
 pyjelly/jelly/__init__.py,sha256=9kacwn8Ew_1fcgj1abz6miEz-AtUdPT2ltFWaRIE5VE,126
 pyjelly/jelly/rdf_pb2.py,sha256=qjgS3kQnCJqoOmgzvgk1BeYxGbeDX2zygJPc2vDjRts,8952
 pyjelly/jelly/rdf_pb2.pyi,sha256=-gxZO-r2wyN68l83XomySz60c82SZmoPKh1HxamBjZs,11816
 pyjelly/parse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyjelly/parse/decode.py,sha256=tVn2e6UmGqjFplIFFlOvZYMb50jCLvkRuaZky45CVNg,14220
-pyjelly/parse/ioutils.py,sha256=O3wRtL5tf1WyIZ1LTfHjHwjKEGrhIWqFisOWjYmspNg,3434
+pyjelly/parse/decode.py,sha256=ze1u7xDz_ySxs4tTqaNN_mpd7GCRN6_Tuz9-xZOwCt8,14381
+pyjelly/parse/ioutils.py,sha256=0eqLmY1lpxRT5PZjx93g8FGfvpfDsXOkZBq2Ag8vptw,3808
 pyjelly/parse/lookup.py,sha256=1AbdZEycLC4tRfh3fgF5hv5PrhwhdWvCUC53iHt-E4c,2193
 pyjelly/serialize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyjelly/serialize/encode.py,sha256=Yr8StCm4u5oJ1ZDFFHnRVnJFtPlCyX7fCFBgmB5Drgw,10521
+pyjelly/serialize/encode.py,sha256=_ACdaxYAoh7z5ND77ceJikKF_AGlZ-P69XPsnl7Fmsg,12664
 pyjelly/serialize/flows.py,sha256=0C2soigJKyHr3xoR-7v0kc1RL8COwnuCRd4iVZpukFU,5524
 pyjelly/serialize/ioutils.py,sha256=2_NaadLfHO3jKR1ZV7aK6jQ09sPKBar9iLFHYwourz8,400
 pyjelly/serialize/lookup.py,sha256=h0lYFjdB6CIuN2DzAW6EE4ILJFUuto3paAK6DG1DZYg,4091
-pyjelly/serialize/streams.py,sha256=F_T3k9yLSPtUW2ZaL99hmjlPKmgG4nYNeNXUiee3jEY,8421
-pyjelly-0.5.3.dist-info/METADATA,sha256=DcX0biLrGr8-C5FnDTsna-hZws_jp_wpgKPI7NsiAbI,4753
-pyjelly-0.5.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pyjelly-0.5.3.dist-info/entry_points.txt,sha256=kUG0p9zso7HpitdMaQaXEj_KSqgOGsL0Ky9ARbecN1g,339
-pyjelly-0.5.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyjelly-0.5.3.dist-info/RECORD,,
+pyjelly/serialize/streams.py,sha256=p4RTQ750C4mT64vDxiK0KcUwD0qaAy-rZ7vwwvV_Cy8,8339
+pyjelly-0.6.1.dist-info/METADATA,sha256=scN1jhC-58MfUscg9VcgWRCBPW4Y9h2_RjlOsxuS6uw,4753
+pyjelly-0.6.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyjelly-0.6.1.dist-info/entry_points.txt,sha256=kUG0p9zso7HpitdMaQaXEj_KSqgOGsL0Ky9ARbecN1g,339
+pyjelly-0.6.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyjelly-0.6.1.dist-info/RECORD,,