pyjelly 0.7.1__cp311-cp311-macosx_11_0_x86_64.whl

pyjelly/serialize/lookup.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from collections import OrderedDict
+from dataclasses import dataclass
+from typing import final
+
+from mypy_extensions import mypyc_attr
+
+
+@mypyc_attr(allow_interpreted_subclasses=True)
+@final
+class Lookup:
+    """
+    Fixed-size 1-based string-to-index mapping with LRU eviction.
+
+    - Assigns incrementing indices starting from 1.
+    - After reaching the maximum size, reuses the existing indices from evicting
+      the least-recently-used entries.
+    - Index 0 is reserved for delta encoding in Jelly streams.
+
+    To check if a key exists, use `.move(key)` and catch `KeyError`.
+    If `KeyError` is raised, the key can be inserted with `.insert(key)`.
+
+    Parameters
+    ----------
+    max_size
+        Maximum number of entries. Zero disables lookup.
+
+    """
+
+    def __init__(self, max_size: int) -> None:
+        self.data = OrderedDict[str, int]()
+        self.max_size = max_size
+        self._evicting = False
+
+    def make_last_to_evict(self, key: str) -> None:
+        self.data.move_to_end(key)
+
+    def insert(self, key: str) -> int:
+        if not self.max_size:
+            msg = "lookup is zero, cannot insert"
+            raise IndexError(msg)
+        assert key not in self.data, f"key {key!r} already present"
+        if self._evicting:
+            _, index = self.data.popitem(last=False)
+            self.data[key] = index
+        else:
+            index = len(self.data) + 1
+            self.data[key] = index
+            self._evicting = index == self.max_size
+        return index
+
+    def __repr__(self) -> str:
+        max_size, data = self.max_size, self.data
+        return f"Lookup({max_size=!r}, {data=!r})"
+
+
+@mypyc_attr(allow_interpreted_subclasses=True)
+@dataclass
+class LookupEncoder:
+    """
+    Shared base for RDF lookup encoders using Jelly compression.
+
+    Tracks the last assigned and last reused index.
+
+    Parameters
+    ----------
+    lookup_size
+        Maximum lookup size.
+
+    """
+
+    last_assigned_index: int
+    last_reused_index: int
+
+    def __init__(self, *, lookup_size: int) -> None:
+        self.lookup = Lookup(max_size=lookup_size)
+        self.last_assigned_index = 0
+        self.last_reused_index = 0
+
+    def encode_entry_index(self, key: str) -> int | None:
+        """
+        Get or assign the index to use in an entry.
+
+        Returns
+        -------
+        int or None
+            - 0 if the new index is sequential (`last_assigned_index + 1`)
+            - actual assigned/reused index otherwise
+            - None if the key already exists
+
+        If the return value is None, the entry is already in the lookup and does not
+        need to be emitted. Any integer value (including 0) means the entry is new
+        and should be emitted.
+
+        """
+        try:
+            self.lookup.make_last_to_evict(key)
+            return None  # noqa: TRY300
+        except KeyError:
+            previous_index = self.last_assigned_index
+            index = self.lookup.insert(key)
+            self.last_assigned_index = index
+            if index == previous_index + 1:
+                return 0
+            return index
+
+    def encode_term_index(self, value: str) -> int:
+        self.lookup.make_last_to_evict(value)
+        current_index = self.lookup.data[value]
+        self.last_reused_index = current_index
+        return current_index
+
+    def encode_prefix_term_index(self, value: str) -> int:
+        if self.lookup.max_size == 0:
+            return 0
+        previous_index = self.last_reused_index
+        if not value and previous_index == 0:
+            return 0
+        current_index = self.encode_term_index(value)
+        if previous_index == 0:
+            return current_index
+        if current_index == previous_index:
+            return 0
+        return current_index
+
+    def encode_name_term_index(self, value: str) -> int:
+        previous_index = self.last_reused_index
+        current_index = self.encode_term_index(value)
+        if current_index == previous_index + 1:
+            return 0
+        return current_index
+
+    def encode_datatype_term_index(self, value: str) -> int:
+        if self.lookup.max_size == 0:
+            return 0
+        return self.encode_term_index(value)

pyjelly/serialize/streams.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+from collections.abc import Generator, Iterable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, ClassVar
+
+from mypy_extensions import mypyc_attr
+
+from pyjelly import jelly
+from pyjelly.options import LookupPreset, StreamParameters, StreamTypes
+from pyjelly.serialize.encode import (
+    Slot,
+    TermEncoder,
+    encode_namespace_declaration,
+    encode_options,
+    encode_quad,
+    encode_triple,
+)
+from pyjelly.serialize.flows import (
+    DEFAULT_FRAME_SIZE,
+    BoundedFrameFlow,
+    FlatQuadsFrameFlow,
+    FlatTriplesFrameFlow,
+    FrameFlow,
+    ManualFrameFlow,
+    flow_for_type,
+)
+
+if TYPE_CHECKING:
+    from jelly import LogicalStreamType  # type: ignore[import-not-found]
+
+
+@dataclass
+class SerializerOptions:
+    flow: FrameFlow | None = None
+    frame_size: int = DEFAULT_FRAME_SIZE
+    logical_type: LogicalStreamType = jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED
+    params: StreamParameters = field(default_factory=StreamParameters)
+    lookup_preset: LookupPreset = field(default_factory=LookupPreset)
+
+
+@mypyc_attr(allow_interpreted_subclasses=True)
+class Stream:
+    physical_type: ClassVar[jelly.PhysicalStreamType]
+    default_delimited_flow_class: ClassVar[type[BoundedFrameFlow]]
+    repeated_terms: list[object | None]
+
+    def __init__(
+        self,
+        *,
+        encoder: TermEncoder,
+        options: SerializerOptions | None = None,
+    ) -> None:
+        self.encoder = encoder
+        if options is None:
+            options = SerializerOptions()
+        self.options = options
+        flow = options.flow
+        if flow is None:
+            flow = self.infer_flow()
+        self.flow = flow
+        self.repeated_terms = [None] * len(Slot)
+        self.enrolled = False
+        self.stream_types = StreamTypes(
+            physical_type=self.physical_type,
+            logical_type=self.flow.logical_type,
+        )
+
+    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:
+                flow_class = flow_for_type(self.options.logical_type)
+            else:
+                flow_class = self.default_delimited_flow_class
+
+            if self.options.logical_type in (
+                jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES,
+                jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS,
+            ):
+                flow = flow_class(
+                    logical_type=self.options.logical_type,
+                    frame_size=self.options.frame_size,
+                )
+            else:
+                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,
+                params=self.options.params,
+                lookup_preset=self.options.lookup_preset,
+            )
+        )
+
+    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,
+            term_encoder=self.encoder,
+        )
+        self.flow.extend(rows)
+
+    @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)
+        from pyjelly.integrations.rdflib.serialize import (  # noqa: PLC0415
+            RDFLibTermEncoder,
+        )
+
+        lookup_preset: LookupPreset | None = None
+        if options is not None:
+            lookup_preset = options.lookup_preset
+        return cls(
+            encoder=RDFLibTermEncoder(lookup_preset=lookup_preset),
+            options=options,
+        )
+
+
+def stream_for_type(physical_type: jelly.PhysicalStreamType) -> type[Stream]:
+    """
+    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:
+        msg = (
+            "no stream class for physical type "
+            f"{jelly.PhysicalStreamType.Name(physical_type)}"
+        )
+        raise NotImplementedError(msg) from None
+    return stream_cls
+
+
+class TripleStream(Stream):
+    physical_type = jelly.PHYSICAL_STREAM_TYPE_TRIPLES
+    default_delimited_flow_class: ClassVar[type[BoundedFrameFlow]] = (
+        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,
+            repeated_terms=self.repeated_terms,
+        )
+        self.flow.extend(new_rows)
+        return self.flow.frame_from_bounds()
+
+
+class QuadStream(Stream):
+    physical_type = jelly.PHYSICAL_STREAM_TYPE_QUADS
+    default_delimited_flow_class: ClassVar = FlatQuadsFrameFlow
+
+    def quad(self, terms: Iterable[object]) -> jelly.RdfStreamFrame | None:
+        """
+        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,
+            repeated_terms=self.repeated_terms,
+        )
+        self.flow.extend(new_rows)
+        return self.flow.frame_from_bounds()
+
+
+class GraphStream(TripleStream):
+    physical_type = jelly.PHYSICAL_STREAM_TYPE_GRAPHS
+    default_delimited_flow_class: ClassVar[type[BoundedFrameFlow]] = FlatQuadsFrameFlow
+
+    def graph(
+        self,
+        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_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:
+            if frame := self.triple(triple):  # has frame slicing inside
+                yield frame
+        end_row = jelly.RdfStreamRow(graph_end=jelly.RdfGraphEnd())
+        self.flow.append(end_row)
+        if frame := self.flow.frame_from_bounds():
+            yield frame
+
+
+STREAM_DISPATCH: dict[jelly.PhysicalStreamType, type[Stream]] = {
+    jelly.PHYSICAL_STREAM_TYPE_TRIPLES: TripleStream,
+    jelly.PHYSICAL_STREAM_TYPE_QUADS: QuadStream,
+    jelly.PHYSICAL_STREAM_TYPE_GRAPHS: GraphStream,
+}

pyjelly-0.7.1.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: pyjelly
+Version: 0.7.1
+Summary: Jelly-RDF implementation for Python
+Project-URL: Homepage, https://w3id.org/jelly/pyjelly
+Project-URL: Documentation, https://w3id.org/jelly/pyjelly
+Project-URL: Repository, https://github.com/Jelly-RDF/pyjelly
+Project-URL: Issues, https://github.com/Jelly-RDF/pyjelly/issues
+Project-URL: Changelog, https://github.com/Jelly-RDF/pyjelly/releases
+Author-email: "NeverBlink et al." <contact@neverblink.eu>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: Jelly,Knowledge graph,RDF,Serialization format
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: Plugins
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: File Formats
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <3.15,>=3.10
+Requires-Dist: mypy-extensions>=1.0.0
+Requires-Dist: protobuf>=6.30.0
+Requires-Dist: typing-extensions>=4.12.2
+Provides-Extra: rdflib
+Requires-Dist: rdflib>=7.1.4; extra == 'rdflib'
+Description-Content-Type: text/markdown
+
+[![Documentation](https://img.shields.io/website?url=https%3A%2F%2Fw3id.org%2Fjelly%2Fpyjelly&label=Documentation)](https://w3id.org/jelly/pyjelly) [![PyPI – Version](https://img.shields.io/pypi/v/pyjelly)](https://pypi.org/project/pyjelly/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyjelly)](https://pypi.org/project/pyjelly/) [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![CI status](https://github.com/Jelly-RDF/pyjelly/actions/workflows/ci.yml/badge.svg)](https://github.com/Jelly-RDF/pyjelly/actions/workflows/ci.yml) [![Code coverage](https://codecov.io/gh/Jelly-RDF/pyjelly/branch/main/graph/badge.svg?token=2D8M2QH6U0)](https://codecov.io/gh/Jelly-RDF/pyjelly) [![Discord](https://img.shields.io/discord/1333391881404420179?label=Discord%20chat)](https://discord.gg/A8sN5XwVa5)
+
+# pyjelly
+
+**pyjelly** is a Python implementation of [Jelly](http://w3id.org/jelly), a high-performance binary serialization format and streaming protocol for RDF knowledge graphs.
+
+**Documentation, usage guide and more: https://w3id.org/jelly/pyjelly**
+
+## Features
+
+- **Fast reading and writing** of RDF knowledge graphs in the [Jelly format](http://w3id.org/jelly).
+- **Standalone [generic API](https://w3id.org/jelly/pyjelly/dev/generic-sink)** with no third-party dependencies, allowing for:
+    - Serialization and parsing of statements to and from Jelly files.
+    - Parsing and serializing streams of graphs and statements.
+- Precise control over **serialization options, framing and compression**.
+- **Seamless** integration with: 
+    - **[rdflib](https://w3id.org/jelly/pyjelly/dev/getting-started)**
+    - **[RDFLib-Neo4j](https://w3id.org/jelly/pyjelly/dev/rdflib-neo4j-integration)**
+    - **[NetworkX](https://w3id.org/jelly/pyjelly/dev/networkx-integration)**
+- **Stream processing support** for large datasets or streams of all [physical stream types](https://w3id.org/jelly/dev/specification/reference/#physicalstreamtype).
+
+**pyjelly** is useful when dealing with (see [full description](https://w3id.org/jelly/pyjelly/dev/overview/#use-cases)):
+
+- Dumping and loading **large RDF datasets**.
+- **Client-server communication**.
+- Workflows, where **streaming** is required.
+
+## Getting started
+
+Install pyjelly from **[PyPI](https://pypi.org/project/pyjelly/)**:
+
+```bash
+pip install pyjelly[rdflib]
+```
+
+To write an RDF graph to a Jelly file:
+
+```python
+from rdflib import Graph
+
+g = Graph()
+g.parse("http://xmlns.com/foaf/spec/index.rdf")
+g.serialize(destination="foaf.jelly", format="jelly")
+```
+
+To read a Jelly file and convert it to an rdflib `Graph`:
+
+```python
+from rdflib import Graph
+
+g = Graph()
+g.parse("foaf.jelly", format="jelly")
+```
+
+**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).
+
+Join the **[Jelly Discord chat](https://discord.gg/A8sN5XwVa5)** to ask questions about pyjelly and to be up-to-date with the development activities.
+
+### Commercial support
+
+**[NeverBlink](https://neverblink.eu)** provides commercial support services for Jelly, including implementing custom features, system integrations, implementations for new frameworks, benchmarking, and more.
+
+### Contributing
+
+If you'd like to contribute, check out our [contributing guidelines](CONTRIBUTING.md).
+
+## License
+
+The pyjelly library is licensed under the [Apache 2.0 license](https://www.apache.org/licenses/LICENSE-2.0).
+
+----
+
+The development of the Jelly protocol, its implementations, and supporting tooling was co-funded by the European Union. **[More details](https://w3id.org/jelly/dev/licensing/projects)**.

pyjelly-0.7.1.dist-info/RECORD

@@ -0,0 +1,41 @@
+cb523b6bada1c6eba8b4__mypyc.cpython-311-darwin.so,sha256=_X6MmZHdZpy0q2WOCYZ4Iej_nTeQPgzl2bbr33x8v6U,846280
+pyjelly/options.py,sha256=u1JseR5HsvSewPe8CI26xDu-v7CM0rpAU5F5kwR8qtA,4545
+pyjelly/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyjelly/errors.py,sha256=R-xRB4a9S19J9dzAL4a5MCaBwb9ev_kvphGFkQJX6ZU,332
+pyjelly/_proto/patch.proto,sha256=gASUm0xDG9J1advNoq_cCsJYxudTbQaiZQBq4oW3kw4,5291
+pyjelly/_proto/rdf.proto,sha256=EKxyG421B4m0Wx5-6jjojdga_hA3jpZfF6-T3lMc0hI,12763
+pyjelly/_proto/grpc.proto,sha256=3PfcZWqKhUSzP_T-xT-80raUYERr_dXWd8rITzXIqek,1188
+pyjelly/parse/lookup.py,sha256=_E9sg4p5X8INeeqAZqmLH_HENpONr3IF-GqWVV6TeJc,2197
+pyjelly/parse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyjelly/parse/decode.cpython-311-darwin.so,sha256=e6mMijg2HhP9Cza1Wj0N-lV7sXBnqfBysz1WGLR4zTI,13288
+pyjelly/parse/ioutils.cpython-311-darwin.so,sha256=TGoTfj2UbdqO_SOTfzZlHIKi_0rKFGFJzMfKvpuB4sw,13288
+pyjelly/parse/lookup.cpython-311-darwin.so,sha256=tIOlNRsyy3oLdMtFe1ziTDK2OCHdzK9B_aANSFklCEQ,13288
+pyjelly/parse/decode.py,sha256=IkXc__ulPnS33FHBzhQqeQJCv35TSnClGMx5-WF6BCw,15017
+pyjelly/parse/ioutils.py,sha256=w7REdMkwlfWu10dxZZ7LdvDNBJksQoRUCVUAACIgiRs,3833
+pyjelly/jelly/rdf_pb2.pyi,sha256=-gxZO-r2wyN68l83XomySz60c82SZmoPKh1HxamBjZs,11816
+pyjelly/jelly/__init__.py,sha256=9kacwn8Ew_1fcgj1abz6miEz-AtUdPT2ltFWaRIE5VE,126
+pyjelly/jelly/rdf_pb2.py,sha256=qjgS3kQnCJqoOmgzvgk1BeYxGbeDX2zygJPc2vDjRts,8952
+pyjelly/serialize/streams.py,sha256=GUfYC5Z8iyXNndgigp6qD5NNBqCpQ-5CVJaJrYVspuk,8634
+pyjelly/serialize/encode.py,sha256=CaI-R4HJXPiL8FLv0uGUy4-mzIgyLb1WCZqhZj_OtF0,12702
+pyjelly/serialize/encode.cpython-311-darwin.so,sha256=B8zRh3cX3fCsQycnWRL2Ddy2z86Fy1yaby32ykkDcT0,13296
+pyjelly/serialize/lookup.py,sha256=4QlekQ-0idEtr8qyYoC6WBKRVk_bwiVAAWrQGtxBgTQ,4225
+pyjelly/serialize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyjelly/serialize/streams.cpython-311-darwin.so,sha256=QuE18MqWUP-6PSAlyC-GP9696IxP7GOde_WtYxp2sk4,13296
+pyjelly/serialize/ioutils.cpython-311-darwin.so,sha256=ABwDwlKxcdTsHUcNGRGWlgxwAqEi9JGFALzHtmcOB5k,13296
+pyjelly/serialize/flows.py,sha256=0C2soigJKyHr3xoR-7v0kc1RL8COwnuCRd4iVZpukFU,5524
+pyjelly/serialize/lookup.cpython-311-darwin.so,sha256=w5u7xrb8saZFeLetGe-IKu2DKz7eBQdWb9vedFOXcZc,13296
+pyjelly/serialize/ioutils.py,sha256=2_NaadLfHO3jKR1ZV7aK6jQ09sPKBar9iLFHYwourz8,400
+pyjelly/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyjelly/integrations/rdflib/serialize.py,sha256=lS2K3UQy1SfKk8x9eX_EA0ubmAg-RDf_JXJ_cBNJj4M,12972
+pyjelly/integrations/rdflib/__init__.py,sha256=lpIz6iildMf5bDvj3aBqZJ7kgKFrTx_tsqSb6PkLis0,552
+pyjelly/integrations/rdflib/parse.py,sha256=9ajBRpl4OJslkcsP2XX3jMG_57IixoOcSEDxp4pMexU,16489
+pyjelly/integrations/generic/serialize.py,sha256=eJYHTtBKvLl82DMPZBn0Ojp1sQrhmTttY9KPuYwYnl4,12494
+pyjelly/integrations/generic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyjelly/integrations/generic/serialize.cpython-311-darwin.so,sha256=RMVGrvE5ZJrHMePCjeCdPuXJHsUWDrWcMXNfEPZW2qo,13328
+pyjelly/integrations/generic/generic_sink.py,sha256=vfc2EKN4cKd3VYLulFThrQ_1ThLKrp2XrG0Afdrnckw,5049
+pyjelly/integrations/generic/parse.py,sha256=tkttb9KUW89n7SrB1SlxhCcROthFoq78TZhb0FAN1wo,12726
+pyjelly-0.7.1.dist-info/RECORD,,
+pyjelly-0.7.1.dist-info/WHEEL,sha256=FF98O_-RqTE3_UpKT5A1SOUKGkcpJJGqmOIOcWT6xWc,134
+pyjelly-0.7.1.dist-info/entry_points.txt,sha256=kUG0p9zso7HpitdMaQaXEj_KSqgOGsL0Ky9ARbecN1g,339
+pyjelly-0.7.1.dist-info/METADATA,sha256=nywNaQz0wEhOx0tS0_sgPW-4N2ksplYbAQHVcWt_L4k,5661
+pyjelly-0.7.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357

pyjelly-0.7.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_11_0_x86_64
+Generator: delocate 0.13.0
+

pyjelly-0.7.1.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[rdf.plugins.parser]
+application/x-jelly-rdf = pyjelly.integrations.rdflib.parse:RDFLibJellyParser
+jelly = pyjelly.integrations.rdflib.parse:RDFLibJellyParser
+
+[rdf.plugins.serializer]
+application/x-jelly-rdf = pyjelly.integrations.rdflib.serialize:RDFLibJellySerializer
+jelly = pyjelly.integrations.rdflib.serialize:RDFLibJellySerializer