pyjelly 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

pyjelly/integrations/rdflib/serialize.py

@@ -1,12 +1,16 @@
+# ruff: noqa: I001
 from __future__ import annotations
-
+from typing import cast
 from collections.abc import Generator
 from functools import singledispatch
-from typing import IO, Any
+from typing import Any, IO
 from typing_extensions import override
+from itertools import chain
+from pyjelly.integrations.rdflib.parse import Quad, Triple
 
 import rdflib
-from rdflib.graph import DATASET_DEFAULT_GRAPH_ID, Dataset, Graph, QuotedGraph
+from rdflib import Graph
+from rdflib.graph import DATASET_DEFAULT_GRAPH_ID, Dataset, QuotedGraph
 from rdflib.serializer import Serializer as RDFLibSerializer
 
 from pyjelly import jelly
@@ -18,7 +22,9 @@ from pyjelly.serialize.streams import (
     SerializerOptions,
     Stream,
     TripleStream,
-)
+)  # ruff: enable
+
+QUAD_ARITY = 4
 
 
 class RDFLibTermEncoder(TermEncoder):
@@ -61,7 +67,10 @@ def namespace_declarations(store: Graph, stream: Stream) -> None:
 
 
 @singledispatch
-def stream_frames(stream: Stream, data: Graph) -> Generator[jelly.RdfStreamFrame]:  # noqa: ARG001
+def stream_frames(
+    stream: Stream,
+    data: Graph | Generator[Quad | Triple],  # noqa: ARG001
+) -> Generator[jelly.RdfStreamFrame]:
     msg = f"invalid stream implementation {stream}"
     raise TypeError(msg)
 
@@ -69,14 +78,15 @@ def stream_frames(stream: Stream, data: Graph) -> Generator[jelly.RdfStreamFrame
 @stream_frames.register(TripleStream)
 def triples_stream_frames(
     stream: TripleStream,
-    data: Graph | Dataset,
+    data: Graph | Dataset | Generator[Triple],
 ) -> Generator[jelly.RdfStreamFrame]:
     """
     Serialize a Graph/Dataset into jelly frames.
 
     Args:
         stream (TripleStream): stream that specifies triples processing
-        data (Graph | Dataset): Graph/Dataset to serialize.
+        data (Graph | Dataset | Generator[Triple]):
+            Graph/Dataset/Statements to serialize.
 
     Notes:
         if Dataset is given, its graphs are unpacked and iterated over
@@ -87,24 +97,24 @@ def triples_stream_frames(
 
     """
     stream.enroll()
-    if stream.options.params.namespace_declarations:
+    if isinstance(data, Graph) and stream.options.params.namespace_declarations:
         namespace_declarations(data, stream)
+
     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
-        # this part turns each graph to a frame for graphs logical type
         if frame := stream.flow.frame_from_graph():
             yield frame
     if stream.stream_types.flat and (frame := stream.flow.to_stream_frame()):
         yield frame
 
 
-@stream_frames.register
+@stream_frames.register(QuadStream)
 def quads_stream_frames(
     stream: QuadStream,
-    data: Dataset,
+    data: Dataset | Generator[Quad],
 ) -> Generator[jelly.RdfStreamFrame]:
     """
     Serialize a Dataset into jelly frames.
@@ -114,17 +124,23 @@ def quads_stream_frames(
 
     Args:
         stream (QuadStream): stream that specifies quads processing
-        data (Dataset): Dataset to serialize.
+        data (Dataset | Generator[Quad]): Dataset to serialize.
 
     Yields:
         Generator[jelly.RdfStreamFrame]: jelly frames
 
     """
-    assert isinstance(data, Dataset)
     stream.enroll()
     if stream.options.params.namespace_declarations:
-        namespace_declarations(data, stream)
-    for terms in data.quads():
+        namespace_declarations(data, stream)  # type: ignore[arg-type]
+
+    iterator: Generator[Quad, None, None]
+    if isinstance(data, Dataset):
+        iterator = cast(Generator[Quad, None, None], data.quads())
+    else:
+        iterator = data
+
+    for terms in iterator:
         if frame := stream.quad(terms):
             yield frame
     if frame := stream.flow.frame_from_dataset():
@@ -133,10 +149,10 @@ def quads_stream_frames(
         yield frame
 
 
-@stream_frames.register
+@stream_frames.register(GraphStream)
 def graphs_stream_frames(
     stream: GraphStream,
-    data: Dataset,
+    data: Dataset | Generator[Quad],
 ) -> Generator[jelly.RdfStreamFrame]:
     """
     Serialize a Dataset into jelly frames as a stream of graphs.
@@ -147,24 +163,76 @@ def graphs_stream_frames(
 
     Args:
         stream (GraphStream): stream that specifies graphs processing
-        data (Dataset): Dataset to serialize.
+        data (Dataset | Generator[Quad]): Dataset to serialize.
 
     Yields:
         Generator[jelly.RdfStreamFrame]: jelly frames
 
     """
-    assert isinstance(data, Dataset)
     stream.enroll()
     if stream.options.params.namespace_declarations:
-        namespace_declarations(data, stream)
-    for graph in data.graphs():
+        namespace_declarations(data, stream)  # type: ignore[arg-type]
+
+    if isinstance(data, Dataset):
+        graphs = data.graphs()
+    else:
+        ds = Dataset()
+        for quad in data:
+            ctx = ds.get_context(quad.g)
+            ctx.add((quad.s, quad.p, quad.o))
+        graphs = ds.graphs()
+
+    for graph in graphs:
         yield from stream.graph(graph_id=graph.identifier, graph=graph)
+
     if frame := stream.flow.frame_from_dataset():
         yield frame
     if stream.stream_types.flat and (frame := stream.flow.to_stream_frame()):
         yield frame
 
 
+def guess_options(sink: Graph | Dataset) -> SerializerOptions:
+    """
+    Guess the serializer options based on the store type.
+
+    >>> guess_options(Graph()).logical_type
+    1
+    >>> guess_options(Dataset()).logical_type
+    2
+    """
+    logical_type = (
+        jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS
+        if isinstance(sink, Dataset)
+        else jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES
+    )
+    return SerializerOptions(logical_type=logical_type)
+
+
+def guess_stream(options: SerializerOptions, sink: Graph | Dataset) -> Stream:
+    """
+    Return an appropriate stream implementation for the given options.
+
+    Notes: if base(!) logical type is GRAPHS and Dataset is given,
+        initializes TripleStream
+
+    >>> graph_ser = RDFLibJellySerializer(Graph())
+    >>> ds_ser = RDFLibJellySerializer(Dataset())
+
+    >>> type(guess_stream(guess_options(graph_ser.store), graph_ser.store))
+    <class 'pyjelly.serialize.streams.TripleStream'>
+    >>> type(guess_stream(guess_options(ds_ser.store), ds_ser.store))
+    <class 'pyjelly.serialize.streams.QuadStream'>
+    """
+    stream_cls: type[Stream]
+    if (options.logical_type % 10) != jelly.LOGICAL_STREAM_TYPE_GRAPHS and isinstance(
+        sink, Dataset
+    ):
+        stream_cls = QuadStream
+    else:
+        stream_cls = TripleStream
+    return stream_cls.for_rdflib(options=options)
+
+
 class RDFLibJellySerializer(RDFLibSerializer):
     """
     RDFLib serializer for writing graphs in Jelly RDF stream format.
@@ -180,43 +248,6 @@ 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,
@@ -240,9 +271,107 @@ class RDFLibJellySerializer(RDFLibSerializer):
 
         """
         if options is None:
-            options = self.guess_options()
+            options = guess_options(self.store)
         if stream is None:
-            stream = self.guess_stream(options)
+            stream = guess_stream(options, self.store)
         write = write_delimited if stream.options.params.delimited else write_single
         for stream_frame in stream_frames(stream, self.store):
             write(stream_frame, out)
+
+
+def grouped_stream_to_frames(
+    sink_generator: Generator[Graph] | Generator[Dataset],
+    options: SerializerOptions | None = None,
+) -> Generator[jelly.RdfStreamFrame]:
+    """
+    Transform Graphs/Datasets into Jelly frames, one frame per Graph/Dataset.
+
+    Note: options are guessed if not provided.
+
+    Args:
+        sink_generator (Generator[Graph] | Generator[Dataset]): Generator of
+            Graphs/Dataset to transform.
+        options (SerializerOptions | None, optional): stream options to use.
+            Options are guessed based on the sink store type. Defaults to None.
+
+    Yields:
+        Generator[jelly.RdfStreamFrame]: produced Jelly frames
+
+    """
+    stream = None
+    for sink in sink_generator:
+        if not stream:
+            if options is None:
+                options = guess_options(sink)
+            stream = guess_stream(options, sink)
+        yield from stream_frames(stream, sink)
+
+
+def grouped_stream_to_file(
+    stream: Generator[Graph] | Generator[Dataset],
+    output_file: IO[bytes],
+    **kwargs: Any,
+) -> None:
+    """
+    Write stream of Graphs/Datasets to a binary file.
+
+    Args:
+        stream (Generator[Graph] | Generator[Dataset]): Generator of
+            Graphs/Dataset to transform.
+        output_file (IO[bytes]): output buffered writer.
+        **kwargs (Any): options to pass to stream.
+
+    """
+    for frame in grouped_stream_to_frames(stream, **kwargs):
+        write_delimited(frame, output_file)
+
+
+def flat_stream_to_frames(
+    statements: Generator[Triple | Quad],
+    options: SerializerOptions | None = None,
+) -> Generator[jelly.RdfStreamFrame]:
+    """
+    Serialize a stream of raw triples or quads into Jelly frames.
+
+    Args:
+        statements (Generator[Triple | Quad]):
+          s/p/o triples or s/p/o/g quads to serialize.
+        options (SerializerOptions | None, optional):
+            if omitted, guessed based on the first tuple.
+
+    Yields:
+        Generator[jelly.RdfStreamFrame]: generated frames.
+
+    """
+    first = next(statements, None)
+    if first is None:
+        return
+
+    sink = Dataset() if len(first) == QUAD_ARITY else Graph()
+    if options is None:
+        options = guess_options(sink)
+    stream = guess_stream(options, sink)
+
+    combined: Generator[Triple | Quad] | Graph = (
+        item for item in chain([first], statements)
+    )
+
+    yield from stream_frames(stream, combined)
+
+
+def flat_stream_to_file(
+    statements: Generator[Triple | Quad],
+    output_file: IO[bytes],
+    options: SerializerOptions | None = None,
+) -> None:
+    """
+    Write Triple or Quad events to a binary file in Jelly flat format.
+
+    Args:
+        statements (Generator[Triple | Quad]): statements to serialize.
+        output_file (IO[bytes]): output buffered writer.
+        options (SerializerOptions | None, optional): stream options.
+
+    """
+    for frame in flat_stream_to_frames(statements, options):
+        write_delimited(frame, output_file)

pyjelly/jelly/rdf_pb2.py

@@ -2,7 +2,7 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # NO CHECKED-IN PROTOBUF GENCODE
 # source: rdf.proto
-# Protobuf Python Version: 5.29.0
+# Protobuf Python Version: 6.31.0
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
@@ -11,8 +11,8 @@ 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,
+    6,
+    31,
     0,
     '',
     'rdf.proto'

pyjelly/jelly/rdf_pb2.pyi

@@ -2,7 +2,8 @@ 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
+from collections.abc import Iterable as _Iterable, Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
 
 DESCRIPTOR: _descriptor.FileDescriptor
 

pyjelly/options.py

@@ -15,6 +15,7 @@ from pyjelly.errors import (
 MIN_NAME_LOOKUP_SIZE: Final[int] = 8
 
 MAX_LOOKUP_SIZE: Final[int] = 4096
+MIN_VERSION: Final[int] = 1
 MAX_VERSION: Final[int] = 2
 
 DEFAULT_NAME_LOOKUP_SIZE: Final[int] = 4000
@@ -97,6 +98,14 @@ class StreamParameters:
     namespace_declarations: bool = False
     stream_name: str = ""
 
+    def __post_init__(self) -> None:
+        selected = MAX_VERSION if self.namespace_declarations else MIN_VERSION
+        if not (MIN_VERSION <= selected <= MAX_VERSION):
+            msg = f"""Error occured while settin up the Stream options.
+            Version must be between {MIN_VERSION} and {MAX_VERSION}."""
+            raise JellyConformanceError(msg)
+        object.__setattr__(self, "version", selected)
+
 
 TRIPLES_ONLY_LOGICAL_TYPES = {
     jelly.LOGICAL_STREAM_TYPE_GRAPHS,

pyjelly/parse/decode.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import ABCMeta, abstractmethod
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable, Iterator, Sequence
 from enum import Enum, auto
 from typing import Any, ClassVar, NamedTuple
 from typing_extensions import Never
@@ -66,6 +66,8 @@ def options_from_frame(
         ),
         params=StreamParameters(
             stream_name=options.stream_name,
+            generalized_statements=options.generalized_statements,
+            rdf_star=options.rdf_star,
             version=options.version,
             delimited=delimited,
         ),
@@ -134,6 +136,11 @@ class Adapter(metaclass=ABCMeta):
             stream_types=self.options.stream_types,
         )
 
+    def quoted_triple(self, terms: Iterable[Any]) -> Any:  # noqa: ARG002
+        _adapter_missing(
+            "decoding quoted triple", stream_types=self.options.stream_types
+        )
+
     def frame(self) -> Any:
         return None
 
@@ -166,23 +173,23 @@ class Decoder:
     def options(self) -> ParserOptions:
         return self.adapter.options
 
-    def decode_frame(self, frame: jelly.RdfStreamFrame) -> Any:
+    def iter_rows(self, frame: jelly.RdfStreamFrame) -> Iterator[Any]:
         """
-        Decode a frame to custom object based on adapter implementation.
+        Iterate through rows in the frame.
 
         Args:
             frame (jelly.RdfStreamFrame): jelly frame
-
-        Returns:
-            Any: custom obj based on adapter logic
+        Yields:
+            Iterator[Any]: decoded rows
 
         """
         for row_owner in frame.rows:
             row = getattr(row_owner, row_owner.WhichOneof("row"))
-            self.decode_row(row)
-        if self.adapter.parsing_mode is ParsingMode.GROUPED:
-            return self.adapter.frame()
-        return None
+            decoded_row = self.decode_row(row)
+            if isinstance(
+                row, (jelly.RdfTriple, jelly.RdfQuad, jelly.RdfNamespaceDeclaration)
+            ):
+                yield decoded_row
 
     def decode_row(self, row: Any) -> Any | None:
         """
@@ -383,6 +390,20 @@ class Decoder:
         terms = self.decode_statement(triple, ("subject", "predicate", "object"))
         return self.adapter.triple(terms)
 
+    def decode_quoted_triple(self, triple: jelly.RdfTriple) -> Any:
+        oneofs: Sequence[str] = ("subject", "predicate", "object")
+        terms = []
+        for oneof in oneofs:
+            field = triple.WhichOneof(oneof)
+            if field:
+                jelly_term = getattr(triple, field)
+                decoded_term = self.decode_term(jelly_term)
+            else:
+                msg = "repeated terms are not allowed in quoted triples"
+                raise ValueError(msg)
+            terms.append(decoded_term)
+        return self.adapter.quoted_triple(terms)
+
     def decode_quad(self, quad: jelly.RdfQuad) -> Any:
         terms = self.decode_statement(quad, ("subject", "predicate", "object", "graph"))
         return self.adapter.quad(terms)
@@ -405,4 +426,5 @@ class Decoder:
         str: decode_bnode,
         jelly.RdfLiteral: decode_literal,
         jelly.RdfDefaultGraph: decode_default_graph,
+        jelly.RdfTriple: decode_quoted_triple,
     }

pyjelly/parse/ioutils.py

@@ -55,8 +55,7 @@ def delimited_jelly_hint(header: bytes) -> bool:
 
 def frame_iterator(inp: IO[bytes]) -> Generator[jelly.RdfStreamFrame]:
     while frame := parse_length_prefixed(jelly.RdfStreamFrame, inp):
-        if frame.rows:
-            yield frame
+        yield frame
 
 
 def get_options_and_frames(
@@ -82,14 +81,21 @@ def get_options_and_frames(
     inp.seek(-len(bytes_read), os.SEEK_CUR)
 
     if is_delimited:
+        first_frame = None
+        skipped_frames = []
         frames = frame_iterator(inp)
-        first_frame = next(frames, None)
+        for frame in frames:
+            if not frame.rows:
+                skipped_frames.append(frame)
+            else:
+                first_frame = frame
+                break
         if first_frame is None:
             msg = "No non-empty frames found in the stream"
             raise JellyConformanceError(msg)
 
         options = options_from_frame(first_frame, delimited=True)
-        return options, chain((first_frame,), frames)
+        return options, chain(skipped_frames, (first_frame,), frames)
 
     frame = parse(jelly.RdfStreamFrame, inp.read())
 

pyjelly/serialize/encode.py

@@ -32,9 +32,8 @@ 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]"
-)
+RowsAndTerm: TypeAlias = "RowsAnd[jelly.RdfIri | jelly.RdfLiteral | str | \
+    jelly.RdfDefaultGraph | jelly.RdfTriple]"
 
 
 class TermEncoder:
@@ -43,6 +42,7 @@ class TermEncoder:
         jelly.RdfLiteral: "literal",
         str: "bnode",
         jelly.RdfDefaultGraph: "default_graph",
+        jelly.RdfTriple: "triple_term",
     }
 
     def __init__(
@@ -163,6 +163,33 @@ class TermEncoder:
             datatype=datatype_id,
         )
 
+    def encode_quoted_triple(self, terms: Iterable[object]) -> RowsAndTerm:
+        """
+        Encode a quoted triple.
+
+        Notes:
+            Although a triple, it is treated as a part of a statement.
+            Repeated terms are not used when encoding quoted triples.
+
+        Args:
+            terms (Iterable[object]): triple terms to encode.
+
+        Returns:
+            RowsAndTerm: additional stream rows with preceeding
+                information (prefixes, names, datatypes rows, if any)
+                and the encoded triple row.
+
+        """
+        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:
         msg = f"unsupported term type: {type(term)}"
         raise NotImplementedError(msg)

pyjelly/serialize/flows.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections import UserList
 from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import ClassVar
+from typing import Any, ClassVar
 from typing_extensions import override
 
 from pyjelly import jelly
@@ -16,11 +16,24 @@ class FrameFlow(UserList[jelly.RdfStreamRow]):
     Abstract base class for producing Jelly frames from RDF stream rows.
 
     Collects stream rows and assembles them into RdfStreamFrame objects when ready.
+
+    Allows for passing LogicalStreamType, required for
+        logical subtypes and non-delimited streams.
     """
 
     logical_type: jelly.LogicalStreamType
     registry: ClassVar[dict[jelly.LogicalStreamType, type[FrameFlow]]] = {}
 
+    def __init__(
+        self,
+        initlist: Iterable[jelly.RdfStreamRow] | None = None,
+        *,
+        logical_type: jelly.LogicalStreamType | None = None,
+        **__kwargs: Any,
+    ) -> None:
+        super().__init__(initlist)
+        self.logical_type = logical_type or self.__class__.logical_type
+
     def frame_from_graph(self) -> jelly.RdfStreamFrame | None:
         """
         Treat the current rows as a graph and produce a frame.
@@ -71,15 +84,6 @@ 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):
@@ -92,13 +96,15 @@ class BoundedFrameFlow(FrameFlow):
     logical_type = jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED
     frame_size: int
 
+    @override
     def __init__(
         self,
         initlist: Iterable[jelly.RdfStreamRow] | None = None,
+        logical_type: jelly.LogicalStreamType | None = None,
         *,
         frame_size: int | None = None,
     ) -> None:
-        super().__init__(initlist)
+        super().__init__(initlist, logical_type=logical_type)
         self.frame_size = frame_size or DEFAULT_FRAME_SIZE
 
     @override
@@ -153,7 +159,6 @@ class DatasetsFrameFlow(FrameFlow):
         return self.to_stream_frame()
 
 
-# TODO(Nastya): issue #184
 FLOW_DISPATCH: dict[jelly.LogicalStreamType, type[FrameFlow]] = {
     jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES: FlatTriplesFrameFlow,
     jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS: FlatQuadsFrameFlow,
@@ -166,18 +171,23 @@ def flow_for_type(logical_type: jelly.LogicalStreamType) -> type[FrameFlow]:
     """
     Return flow based on logical type requested.
 
+    Note: uses base logical type for subtypes (i.e., SUBJECT_GRAPHS uses
+        the same flow as its base type GRAPHS).
+
     Args:
         logical_type (jelly.LogicalStreamType): logical type requested.
 
     Raises:
-        NotImplementedError: if logical type not supported.
+        NotImplementedError: if (base) logical stream type is not supported.
 
     Returns:
         type[FrameFlow]: FrameFlow for respective logical type.
 
     """
     try:
-        return FLOW_DISPATCH[logical_type]
+        base_logical_type_value = logical_type % 10
+        base_name = jelly.LogicalStreamType.Name(base_logical_type_value)
+        return FLOW_DISPATCH[getattr(jelly.LogicalStreamType, base_name)]
     except KeyError:
         msg = (
             "unsupported logical stream type: "