pyjelly 0.5.3__tar.gz → 0.6.0__tar.gz

{pyjelly-0.5.3 → pyjelly-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyjelly
-Version: 0.5.3
+Version: 0.6.0
 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 → pyjelly-0.6.0}/docs/contributing/index.md

@@ -93,9 +93,6 @@ uv run mkdocs serve
 ## Making releases
 
 1. Make sure you are on the `main` branch and that it is up-to-date: `git checkout main && git pull`.
-2. Checkout a new branch.
-3. Commit the changes, push the branch, and open a pull request.
-4. Once the pull request is merged, go back to the `main` branch: `git checkout main && git pull`.
-5. Create a new tag for the release. For example, for version 1.2.3: `git tag v1.2.3`. **The tag must start with `v`!**
-6. Push the tag to GitHub: `git push origin v1.2.3`.
-7. The release will be automatically built and published to PyPI.
+2. Create a new tag for the release. For example, for version 1.2.3: `git tag v1.2.3`. **The tag must start with `v`!**
+3. Push the tag to GitHub: `git push origin v1.2.3`.
+4. The release will be automatically built and published to PyPI.

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/env.py

@@ -37,7 +37,7 @@ def define_env(env):
 
     try:
         python_tag_raw = subprocess.check_output(
-            ["uv", "version", "--short"], encoding="utf-8"
+            ["git", "describe", "--tags"], encoding="utf-8"
         ).strip()
     except subprocess.CalledProcessError as e:
         print("Failed to call git: ", e.returncode, e.stderr)

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/examples/generic/01_serialize.py

@@ -1,13 +1,7 @@
-from pyjelly.integrations.generic.generic_sink import (
-    IRI,
-    BlankNode,
-    GenericStatementSink,
-    Literal,
-    Triple,
-)
+from pyjelly.integrations.generic.generic_sink import *
 
-# Create a generic sink object, identifier is optional
-generic_sink = GenericStatementSink(identifier="my_graph")
+# Create a generic sink object
+generic_sink = GenericStatementSink()
 
 # Let's add triples one by one
 generic_sink.add(

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/examples/generic/02_parse.py

@@ -1,7 +1,7 @@
-from pyjelly.integrations.generic.generic_sink import GenericStatementSink, Triple
+from pyjelly.integrations.generic.generic_sink import *
 
-# Create a generic sink object, identifier is optional
-generic_sink = GenericStatementSink(identifier="my_graph")
+# Create a generic sink object
+generic_sink = GenericStatementSink()
 
 # Load triples from the Jelly file
 with open("output.jelly", "rb") as in_file:

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/examples/generic/03_streaming.py

@@ -1,4 +1,4 @@
-from pyjelly.integrations.generic.generic_sink import GenericStatementSink
+from pyjelly.integrations.generic.generic_sink import *
 
 
 # Helper generator that streams statements from a Jelly file path

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/examples/generic/04_serialize_grouped.py

@@ -1,8 +1,4 @@
-from pyjelly.integrations.generic.generic_sink import (
-    GenericStatementSink,
-    IRI,
-    Triple,
-)
+from pyjelly.integrations.generic.generic_sink import *
 from pyjelly.integrations.generic.serialize import grouped_stream_to_file
 import random
 
@@ -14,8 +10,8 @@ def generate_sample_sinks():
         IRI("http://example.com/humidity"),
         IRI(f"http://example.com/{random.random()}"),
     )
-    for i in range(10):
-        sink = GenericStatementSink(identifier=f"graph_{i}")
+    for _ in range(10):
+        sink = GenericStatementSink()
         sink.add(Triple(*content))
         yield sink
 

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/examples/generic/05_serialize_flat.py

@@ -1,5 +1,5 @@
 from pyjelly.integrations.generic.serialize import flat_stream_to_file
-from pyjelly.integrations.generic.generic_sink import Triple, IRI
+from pyjelly.integrations.generic.generic_sink import *
 import random
 
 

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/examples/generic/07_parse_flat.py

@@ -1,10 +1,7 @@
 import gzip
 import urllib.request
 
-from pyjelly.integrations.generic.generic_sink import (
-    IRI,
-    Triple,
-)
+from pyjelly.integrations.generic.generic_sink import *
 from pyjelly.integrations.generic.parse import parse_jelly_flat
 
 # Dataset: OpenStreetMap data for Denmark (first 10k objects)

pyjelly-0.6.0/docs/examples/generic/08_byte_buffer.py

@@ -0,0 +1,29 @@
+import io
+
+from pyjelly.integrations.generic.generic_sink import *
+
+g1 = GenericStatementSink()
+
+g1.add(
+    Triple(
+        IRI("http://example.com/subject"),
+        IRI("http://example.com/predicate"),
+        Literal("Hello", langtag="en"),
+    )
+)
+
+# Write the data into a byte buffer (bytes type)
+with io.BytesIO() as write_buffer:
+    g1.serialize(write_buffer)
+    data = write_buffer.getvalue()
+
+print(f"Serialized data size: {len(data)} bytes")
+
+# Parse the data back
+g2 = GenericStatementSink()
+with io.BytesIO(data) as read_buffer:
+    g2.parse(read_buffer)
+
+print("\nParsed triples:")
+for statement in g2:
+    print(statement)

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/examples/networkx_integration/01_parse_calculate_visualize.py

@@ -1,9 +1,9 @@
 import urllib.request, gzip, tempfile, shutil, os
-from rdflib import Graph
-from rdflib.extras.external_graph_libs import rdflib_to_networkx_graph
+
 import networkx as nx
 import matplotlib.pyplot as plt
 from rdflib import Graph, URIRef, BNode, Literal
+from rdflib.extras.external_graph_libs import rdflib_to_networkx_graph
 
 # Filter predicates for people
 TARGET_PREDICATES = {

pyjelly-0.6.0/docs/examples/rdflib/08_namespaces.py

@@ -0,0 +1,21 @@
+from rdflib import Graph, Namespace, URIRef, Literal
+from pyjelly.integrations.rdflib.serialize import SerializerOptions, StreamParameters
+
+# Build a tiny graph and bind a prefix
+g = Graph()
+EX = Namespace("http://example.org/")
+g.namespace_manager.bind("ex", EX)
+g.add((EX.alice, URIRef("http://xmlns.com/foaf/0.1/name"), Literal("Alice")))
+
+print("IN  namespaces:", dict(g.namespaces()))
+
+# Enable namespace declarations in Jelly output
+options = SerializerOptions(params=StreamParameters(namespace_declarations=True))
+
+# Serialize with options
+g.serialize("sample_test.jelly", format="jelly", options=options)
+
+# Parse back and check namespaces
+g_new = Graph()
+g_new.parse("sample_test.jelly", format="jelly")
+print("OUT namespaces:", dict(g_new.namespaces()))

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/generic-sink.md

@@ -75,7 +75,17 @@ Serializing a generator object of statements to `.jelly` file through generic AP
 
 {{ code_example('generic/05_serialize_flat.py')}}
 
-Data is transmitted and kept ordered and simple. 
+Data is transmitted and kept ordered and simple.
+
+### Working with byte buffers and Kafka
+
+When working with Kafka or other message brokers, you may want to write Jelly data to a byte buffer instead of a file. You can do this by using the `BytesIO` class from the `io` module:
+
+{{ code_example('generic/08_byte_buffer.py')}}
+
+The `data` variable is of type `bytes`, and can be passed to Kafka with [`KafkaProducer.send(value=data)`](https://kafka-python.readthedocs.io/en/master/), or any other API that accepts byte buffers. Same trick may be used when working with the [RDFLib integration](getting-started.md).
+
+When working with Kafka, you should be aware of the broker's offset management and partitioning strategies. Data within one Jelly stream must be strictly ordered and no frames may be dropped. If you have less strict ordering guarantees, you should split up the stream into multiple Jelly streams, each with guaranteed consistency.
 
 ### See also
 

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/getting-started.md

@@ -27,6 +27,22 @@ To serialize a graph to the Jelly format see:
 
 This creates a [delimited Jelly stream]({{ proto_link("user-guide/#delimited-vs-non-delimited-jelly") }}) using default options.
 
+### Including namespace declarations (prefixes)
+
+By default, Jelly serializes only triples/quads. To also include namespace declarations (prefixes) in the output, enable the `namespace_declarations` option.
+Prefixes bound in RDFLib's namespace manager will then be written into the Jelly stream and restored on parsing.
+
+{{ code_example('rdflib/08_namespaces.py') }}
+
+!!! tip
+    
+    For an existing graph you can (re)bind a prefix just before saving:
+    
+    ```python
+    g.namespace_manager.bind("ex", EX, replace=True)
+    ```
+
+
 ### Parsing a graph
 
 To load RDF data from a `.jelly` file see:
@@ -81,4 +97,10 @@ You can generally omit the `format="jelly"` parameter if the file ends in `.jell
 
 !!! warning 
 
-    Unfortunately, the way this is implemented in RDFLib is a bit wonky, so it will only work if you explicitly import `pyjelly.integrations.rdflib`, or you used `format="jelly"` in the `serialize()` or `parse()` call before.
+    Unfortunately, the way this is implemented in RDFLib is a bit wonky, so it will only work if you explicitly import `pyjelly.integrations.rdflib`, or you used `format="jelly"` in the `serialize()` or `parse()` call before.
+
+## See also
+
+- [Working with byte buffers and Kafka](generic-sink.md#working-with-byte-buffers-and-kafka)
+- [Usage without RDFLib](generic-sink.md)
+- [API reference](api.md)

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/index.md

@@ -18,6 +18,19 @@
 - **[API reference](api.md)**
 - **[Contributing](contributing/index.md)** – how to report issues, contribute code, and request features
 
+## Compatibility
+
+pyjelly is compatible with Python 3.9 and newer. Python 3.9–3.13 are tested in CI and are guaranteed to work.
+
+The following table shows the compatibility of the pyjelly implementation with other libraries:
+
+| pyjelly                                                                                                                                             | Python     | RDFLib         |
+|-----------------------------------------------------------------------------------------------------------------------------------------------------|------------|----------------|
+| [0.1.0](https://w3id.org/jelly/pyjelly/0.1.0) – **[{{ python_package_version() }}](https://w3id.org/jelly/pyjelly/{{ python_package_version() }})** | 3.9 – 3.13 | 7.x (>= 7.1.4) |
+
+
+See the **[release notes on GitHub](https://github.com/Jelly-RDF/pyjelly/releases)** for more details.
+
 ## Commercial and community support
 
 **[NeverBlink](https://neverblink.eu)** provides commercial support services for Jelly, including implementing custom features, system integrations, implementations for new frameworks, benchmarking, and more.

{pyjelly-0.5.3 → pyjelly-0.6.0}/docs/rdflib-neo4j-integration.md

@@ -1,5 +1,9 @@
 # RDFLib-Neo4j
 
+!!! info
+
+    This is an integration with Neo4j via the [RDFLib-Neo4j](https://neo4j.com/labs/rdflib-neo4j/) library. It works with all Neo4j instances, including AuraDB, but is limited in features and performance. If you are self-hosting Neo4j (Neo4j Desktop or Community/Enterprise), consider using the **[Jelly-Neo4j plugin for neosemantics](https://w3id.org/jelly/jelly-jvm/dev/getting-started-neo4j/)**, which offers better performance and more features.
+
 RDFLib-Neo4j lets you import RDF triples into Neo4j via the RDFLib API.
 
 Install the following library:  
@@ -22,3 +26,4 @@ For more information, visit:
 
 - [RDFLib-Neo4j (GitHub)](https://github.com/neo4j-labs/rdflib-neo4j)
 - [Neo4j Labs: RDFLib-Neo4j](https://neo4j.com/labs/rdflib-neo4j/)
+- [Alternative: Jelly-Neo4j plugin for neosemantics](https://w3id.org/jelly/jelly-jvm/dev/getting-started-neo4j/)

{pyjelly-0.5.3 → pyjelly-0.6.0}/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-0.5.3 → pyjelly-0.6.0}/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-0.5.3 → pyjelly-0.6.0}/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: