pyjelly 0.2.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

pyjelly/serialize/encode.py

@@ -11,6 +11,16 @@ from pyjelly.serialize.lookup import LookupEncoder
 
 
 def split_iri(iri_string: str) -> tuple[str, str]:
+    """
+    Split iri into prefix and name.
+
+    Args:
+        iri_string (str): full iri string.
+
+    Returns:
+        tuple[str, str]: iri's prefix and name.
+
+    """
     name = iri_string
     prefix = ""
     for sep in "#", "/":
@@ -47,6 +57,16 @@ class TermEncoder:
         self.datatypes = LookupEncoder(lookup_size=lookup_preset.max_datatypes)
 
     def encode_iri(self, iri_string: str) -> RowsAnd[jelly.RdfIri]:
+        """
+        Encode iri.
+
+        Args:
+            iri_string (str): full iri in string format.
+
+        Returns:
+            RowsAnd[jelly.RdfIri]: extra rows and protobuf RdfIri message.
+
+        """
         prefix, name = split_iri(iri_string)
         if self.prefixes.lookup.max_size:
             prefix_entry_index = self.prefixes.encode_entry_index(prefix)
@@ -70,9 +90,27 @@ class TermEncoder:
         return term_rows, jelly.RdfIri(prefix_id=prefix_index, name_id=name_index)
 
     def encode_default_graph(self) -> RowsAnd[jelly.RdfDefaultGraph]:
+        """
+        Encode default graph.
+
+        Returns:
+            RowsAnd[jelly.RdfDefaultGraph]: empty extra rows and
+                default graph message.
+
+        """
         return (), jelly.RdfDefaultGraph()
 
     def encode_bnode(self, bnode: str) -> RowsAnd[str]:
+        """
+        Encode blank node (BN).
+
+        Args:
+            bnode (str): BN internal identifier in string format.
+
+        Returns:
+            RowsAnd[str]: empty extra rows and original BN string.
+
+        """
         return (), bnode
 
     def encode_literal(
@@ -82,6 +120,24 @@ class TermEncoder:
         language: str | None = None,
         datatype: str | None = None,
     ) -> RowsAnd[jelly.RdfLiteral]:
+        """
+        Encode literal.
+
+        Args:
+            lex (str): lexical form/literal value
+            language (str | None, optional): langtag. Defaults to None.
+            datatype (str | None, optional): data type if
+            it is a typed literal. Defaults to None.
+
+        Raises:
+            JellyConformanceError: if datatype specified while
+                datatable is not used.
+
+        Returns:
+            RowsAnd[jelly.RdfLiteral]: extra rows (i.e., datatype entries)
+                and RdfLiteral message.
+
+        """
         datatype_id = None
         term_rows: tuple[()] | tuple[jelly.RdfStreamRow] = ()
 
@@ -129,6 +185,19 @@ def encode_statement(
     term_encoder: TermEncoder,
     repeated_terms: dict[Slot, object],
 ) -> tuple[list[jelly.RdfStreamRow], dict[str, Any]]:
+    """
+    Encode a statement.
+
+    Args:
+        terms (Iterable[object]): original terms to encode
+        term_encoder (TermEncoder): encoder with lookup tables
+        repeated_terms (dict[Slot, object]): dictionary of repeated terms.
+
+    Returns:
+        tuple[list[jelly.RdfStreamRow], dict[str, Any]]:
+            extra rows to append and jelly terms.
+
+    """
     statement: dict[str, object] = {}
     rows: list[jelly.RdfStreamRow] = []
     for slot, term in zip(Slot, terms):
@@ -147,6 +216,18 @@ def encode_triple(
     term_encoder: TermEncoder,
     repeated_terms: dict[Slot, object],
 ) -> list[jelly.RdfStreamRow]:
+    """
+    Encode one 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.
+
+    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))
     rows.append(row)
@@ -158,6 +239,18 @@ def encode_quad(
     term_encoder: TermEncoder,
     repeated_terms: dict[Slot, object],
 ) -> list[jelly.RdfStreamRow]:
+    """
+    Encode one 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.
+
+    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))
     rows.append(row)
@@ -169,6 +262,18 @@ def encode_namespace_declaration(
     value: str,
     term_encoder: TermEncoder,
 ) -> list[jelly.RdfStreamRow]:
+    """
+    Encode namespace declaration.
+
+    Args:
+        name (str): namespace prefix label
+        value (str): namespace iri
+        term_encoder (TermEncoder): current encoder
+
+    Returns:
+        list[jelly.RdfStreamRow]: list of messages to append to current flow.
+
+    """
     [*rows], iri = term_encoder.encode_iri(value)
     declaration = jelly.RdfNamespaceDeclaration(name=name, value=iri)
     row = jelly.RdfStreamRow(namespace=declaration)
@@ -181,6 +286,18 @@ def encode_options(
     stream_types: options.StreamTypes,
     params: options.StreamParameters,
 ) -> jelly.RdfStreamRow:
+    """
+    Encode stream options to ProtoBuf message.
+
+    Args:
+        lookup_preset (options.LookupPreset): lookup tables options
+        stream_types (options.StreamTypes): physical and logical types
+        params (options.StreamParameters): other params.
+
+    Returns:
+        jelly.RdfStreamRow: encoded stream options row
+
+    """
     return jelly.RdfStreamRow(
         options=jelly.RdfStreamOptions(
             stream_name=params.stream_name,

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.
@@ -41,6 +54,16 @@ class FrameFlow(UserList[jelly.RdfStreamRow]):
         return None
 
     def to_stream_frame(self) -> jelly.RdfStreamFrame | None:
+        """
+        Create stream frame from flow content.
+
+        Notes:
+            Clears flow content after creating the frame.
+
+        Returns:
+            jelly.RdfStreamFrame | None: stream frame
+
+        """
         if not self:
             return None
         frame = jelly.RdfStreamFrame(rows=self)
@@ -61,20 +84,11 @@ 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):
     """
-    Produces frames automatically when a fixed number of rows is reached.
+    Produce frames automatically when a fixed number of rows is reached.
 
     Used for delimited encoding (default mode).
     """
@@ -82,17 +96,26 @@ 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
     def frame_from_bounds(self) -> jelly.RdfStreamFrame | None:
+        """
+        Emit frame from flow if full.
+
+        Returns:
+            jelly.RdfStreamFrame | None: stream frame
+
+        """
         if len(self) >= self.frame_size:
             return self.to_stream_frame()
         return None
@@ -110,6 +133,14 @@ class GraphsFrameFlow(FrameFlow):
     logical_type = jelly.LOGICAL_STREAM_TYPE_GRAPHS
 
     def frame_from_graph(self) -> jelly.RdfStreamFrame | None:
+        """
+        Emit current flow content (one graph) as jelly frame.
+
+        Returns:
+            jelly.RdfStreamFrame | None: jelly frame or none if
+                flow is empty.
+
+        """
         return self.to_stream_frame()
 
 
@@ -117,6 +148,14 @@ class DatasetsFrameFlow(FrameFlow):
     logical_type = jelly.LOGICAL_STREAM_TYPE_DATASETS
 
     def frame_from_dataset(self) -> jelly.RdfStreamFrame | None:
+        """
+        Emit current flow content (dataset) as jelly frame.
+
+        Returns:
+            jelly.RdfStreamFrame | None: jelly frame or none if
+                flow is empty.
+
+        """
         return self.to_stream_frame()
 
 
@@ -129,8 +168,26 @@ FLOW_DISPATCH: dict[jelly.LogicalStreamType, type[FrameFlow]] = {
 
 
 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 (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: "

pyjelly/serialize/streams.py

@@ -60,6 +60,13 @@ class Stream:
         )
 
     def infer_flow(self) -> FrameFlow:
+        """
+        Return flow based on the stream options provided.
+
+        Returns:
+            FrameFlow: initialised FrameFlow object.
+
+        """
         flow: FrameFlow
         if self.options.params.delimited:
             if self.options.logical_type != jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED:
@@ -71,19 +78,24 @@ class Stream:
                 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]
+                flow = flow_class(
+                    logical_type=self.options.logical_type,
+                    frame_size=self.options.frame_size,
+                )
             else:
-                flow = flow_class()
+                flow = flow_class(logical_type=self.options.logical_type)
         else:
             flow = ManualFrameFlow(logical_type=self.options.logical_type)
         return flow
 
     def enroll(self) -> None:
+        """Initialize start of the stream."""
         if not self.enrolled:
             self.stream_options()
             self.enrolled = True
 
     def stream_options(self) -> None:
+        """Encode and append stream options row to the current flow."""
         self.flow.append(
             encode_options(
                 stream_types=self.stream_types,
@@ -93,6 +105,14 @@ class Stream:
         )
 
     def namespace_declaration(self, name: str, iri: str) -> None:
+        """
+        Add namespace declaration to jelly stream.
+
+        Args:
+            name (str): namespace prefix label
+            iri (str): namespace iri
+
+        """
         rows = encode_namespace_declaration(
             name=name,
             value=iri,
@@ -102,6 +122,20 @@ class Stream:
 
     @classmethod
     def for_rdflib(cls, options: SerializerOptions | None = None) -> Stream:
+        """
+        Initialize stream with RDFLib encoder.
+
+        Args:
+            options (SerializerOptions | None, optional): Stream options.
+                Defaults to None.
+
+        Raises:
+            TypeError: if Stream is passed, and not a Stream for specific physical type.
+
+        Returns:
+            Stream: initialized stream with RDFLib encoder.
+
+        """
         if cls is Stream:
             msg = "Stream is an abstract base class, use a subclass instead"
             raise TypeError(msg)
@@ -117,6 +151,19 @@ class Stream:
 
 
 def stream_for_type(physical_type: jelly.PhysicalStreamType) -> type[Stream]:
+    """
+    Give a Stream based on physical type specified.
+
+    Args:
+        physical_type (jelly.PhysicalStreamType): jelly stream physical type.
+
+    Raises:
+        NotImplementedError: if no stream for requested physical type is available.
+
+    Returns:
+        type[Stream]: jelly stream
+
+    """
     try:
         stream_cls = STREAM_DISPATCH[physical_type]
     except KeyError:
@@ -133,6 +180,21 @@ class TripleStream(Stream):
     default_delimited_flow_class: ClassVar = FlatTriplesFrameFlow
 
     def triple(self, terms: Iterable[object]) -> jelly.RdfStreamFrame | None:
+        """
+        Process one triple to Protobuf messages.
+
+        Note:
+            Adds new rows to the current flow and returns StreamFrame if
+            frame size conditions are met.
+
+        Args:
+            terms (Iterable[object]): RDF terms to encode.
+
+        Returns:
+            jelly.RdfStreamFrame | None: stream frame if
+                flow supports frames slicing and current flow is full
+
+        """
         new_rows = encode_triple(
             terms,
             term_encoder=self.encoder,
@@ -147,6 +209,17 @@ class QuadStream(Stream):
     default_delimited_flow_class: ClassVar = FlatQuadsFrameFlow
 
     def quad(self, terms: Iterable[object]) -> jelly.RdfStreamFrame | None:
+        """
+        Process one quad to Protobuf messages.
+
+        Args:
+            terms (Iterable[object]): terms to encode.
+
+        Returns:
+            jelly.RdfStreamFrame | None: stream frame if
+                flow supports frames slicing and current flow is full
+
+        """
         new_rows = encode_quad(
             terms,
             term_encoder=self.encoder,
@@ -165,6 +238,17 @@ class GraphStream(TripleStream):
         graph_id: object,
         graph: Iterable[Iterable[object]],
     ) -> Generator[jelly.RdfStreamFrame]:
+        """
+        Process one graph into a sequence of jelly frames.
+
+        Args:
+            graph_id (object): graph id (BN, Literal, iri, default)
+            graph (Iterable[Iterable[object]]): iterable of triples (graph's content)
+
+        Yields:
+            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}
@@ -172,7 +256,7 @@ class GraphStream(TripleStream):
         graph_rows.append(start_row)
         self.flow.extend(graph_rows)
         for triple in graph:
-            if frame := self.triple(triple):
+            if frame := self.triple(triple):  # has frame slicing inside
                 yield frame
         end_row = jelly.RdfStreamRow(graph_end=jelly.RdfGraphEnd())
         self.flow.append(end_row)

{pyjelly-0.2.3.dist-info → pyjelly-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyjelly
-Version: 0.2.3
+Version: 0.4.0
 Summary: Jelly-RDF implementation for Python
 Project-URL: Homepage, https://w3id.org/jelly/pyjelly
 Project-URL: Documentation, https://w3id.org/jelly/pyjelly
@@ -28,7 +28,7 @@ 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: protobuf>=6.30.0
 Requires-Dist: typing-extensions>=4.12.2
 Provides-Extra: rdflib
 Requires-Dist: rdflib>=7.1.4; extra == 'rdflib'
@@ -50,13 +50,13 @@ Description-Content-Type: text/markdown
 
 ## Getting started
 
-To get started with pyjelly, you can install it via pip:
+Install pyjelly from **[PyPI](https://pypi.org/project/pyjelly/)**:
 
 ```bash
 pip install pyjelly[rdflib]
 ```
 
-To write an RDF graph to a Jelly file, you can use the following code:
+To write an RDF graph to a Jelly file:
 
 ```python
 from rdflib import Graph
@@ -66,7 +66,7 @@ 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:
+To read a Jelly file and convert it to an rdflib `Graph`:
 
 ```python
 from rdflib import Graph
@@ -75,19 +75,19 @@ 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).**
+**See [our documentation](https://w3id.org/jelly/pyjelly) for [further examples](https://w3id.org/jelly/pyjelly/dev/getting-started/), a full [API reference](https://w3id.org/jelly/pyjelly/dev/api), and more.**
 
 ## 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.
+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
+### Contributing
 
 If you'd like to contribute, check out our [contributing guidelines](CONTRIBUTING.md).
 

{pyjelly-0.2.3.dist-info → pyjelly-0.4.0.dist-info}/RECORD

@@ -6,23 +6,23 @@ 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/rdflib/__init__.py,sha256=lpIz6iildMf5bDvj3aBqZJ7kgKFrTx_tsqSb6PkLis0,552
-pyjelly/integrations/rdflib/parse.py,sha256=ZjFQt72U64jpVSuyVHq28H9cSNISl8O4_W_HlyqtZXQ,9738
-pyjelly/integrations/rdflib/serialize.py,sha256=5M17BN5LKSR5bPX2V97AjKNRF9UKQHwj1CMreILCUE4,6044
+pyjelly/integrations/rdflib/parse.py,sha256=_H4f5qUU0IvMPaq1Tnm2UF1aXX-DY1qPn_7GmoIa4V0,13717
+pyjelly/integrations/rdflib/serialize.py,sha256=etFY10HjmsjmuR6BjvWw32f2zBThW26mTGFn67jcOdc,9524
 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/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=LJHWBXqYP0Bk4_3FIxeTNXPCRVbWMU3YzFObrzvcIzE,8910
-pyjelly/parse/ioutils.py,sha256=m7Kxqw0lAhM7swFuDWPRBE3ngjkiYRVUoM2O1QOVyT4,2720
+pyjelly/parse/decode.py,sha256=ERgCLzBvbkJWTlg3RT0p-h8J60KNqpQ4mj_-JHoD7kg,13299
+pyjelly/parse/ioutils.py,sha256=O3wRtL5tf1WyIZ1LTfHjHwjKEGrhIWqFisOWjYmspNg,3434
 pyjelly/parse/lookup.py,sha256=1AbdZEycLC4tRfh3fgF5hv5PrhwhdWvCUC53iHt-E4c,2193
 pyjelly/serialize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyjelly/serialize/encode.py,sha256=U3B2VkEO3J0bABTF18rvC8FCzqsi4Xo1RqtHCMbaub0,6485
-pyjelly/serialize/flows.py,sha256=mCGJnR7UyuAPn4EArXaBt3llpZ3_iwLq90bQwRTbhpg,3933
+pyjelly/serialize/encode.py,sha256=WSeqxyBtxpMrWrefhnmNLf8ummzlT0rY7NKoUzFY8NQ,9498
+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=JiYHZc2YkyWuSspsLBybGimBpTOPZJSrzC8fRVYQ2p8,6117
-pyjelly-0.2.3.dist-info/METADATA,sha256=HMt_jMiX1747sWvWf4DnKWLpK54GVyTYqD3t8Crlxzo,4585
-pyjelly-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pyjelly-0.2.3.dist-info/entry_points.txt,sha256=kUG0p9zso7HpitdMaQaXEj_KSqgOGsL0Ky9ARbecN1g,339
-pyjelly-0.2.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyjelly-0.2.3.dist-info/RECORD,,
+pyjelly/serialize/streams.py,sha256=F_T3k9yLSPtUW2ZaL99hmjlPKmgG4nYNeNXUiee3jEY,8421
+pyjelly-0.4.0.dist-info/METADATA,sha256=iLIzLhRWIN9fj1Fua45fBosWbLS1bQOnLZmVsGbfFQw,4607
+pyjelly-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyjelly-0.4.0.dist-info/entry_points.txt,sha256=kUG0p9zso7HpitdMaQaXEj_KSqgOGsL0Ky9ARbecN1g,339
+pyjelly-0.4.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyjelly-0.4.0.dist-info/RECORD,,