pyjelly 0.1.0__py3-none-any.whl

pyjelly/serialize/encode.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from enum import Enum
+from typing import Any, ClassVar, TypeVar
+from typing_extensions import TypeAlias
+
+from pyjelly import jelly, options
+from pyjelly.errors import JellyConformanceError
+from pyjelly.serialize.lookup import LookupEncoder
+
+
+def split_iri(iri_string: str) -> tuple[str, str]:
+    name = iri_string
+    prefix = ""
+    for sep in "#", "/":
+        prefix, char, name = iri_string.rpartition(sep)
+        if char:
+            return prefix + char, name
+    return prefix, name
+
+
+T = TypeVar("T")
+RowsAnd: TypeAlias = tuple[Sequence[jelly.RdfStreamRow], T]
+RowsAndTerm: TypeAlias = (
+    "RowsAnd[jelly.RdfIri | jelly.RdfLiteral | str | jelly.RdfDefaultGraph]"
+)
+
+
+class TermEncoder:
+    TERM_ONEOF_NAMES: ClassVar = {
+        jelly.RdfIri: "iri",
+        jelly.RdfLiteral: "literal",
+        str: "bnode",
+        jelly.RdfDefaultGraph: "default_graph",
+    }
+
+    def __init__(
+        self,
+        max_names: int = options.DEFAULT_NAME_LOOKUP_SIZE,
+        max_prefixes: int = options.DEFAULT_PREFIX_LOOKUP_SIZE,
+        max_datatypes: int = options.DEFAULT_DATATYPE_LOOKUP_SIZE,
+    ) -> None:
+        self.names = LookupEncoder(lookup_size=max_names)
+        self.prefixes = LookupEncoder(lookup_size=max_prefixes)
+        self.datatypes = LookupEncoder(lookup_size=max_datatypes)
+
+    def encode_iri(self, iri_string: str) -> RowsAnd[jelly.RdfIri]:
+        prefix, name = split_iri(iri_string)
+        if prefix and self.prefixes.lookup.max_size:
+            prefix_entry_index = self.prefixes.encode_entry_index(prefix)
+        else:
+            name = iri_string
+            prefix_entry_index = None
+
+        name_entry_index = self.names.encode_entry_index(name)
+
+        term_rows = []
+
+        if prefix_entry_index is not None:
+            prefix_entry = jelly.RdfPrefixEntry(id=prefix_entry_index, value=prefix)
+            term_rows.append(jelly.RdfStreamRow(prefix=prefix_entry))
+
+        if name_entry_index is not None:
+            name_entry = jelly.RdfNameEntry(id=name_entry_index, value=name)
+            term_rows.append(jelly.RdfStreamRow(name=name_entry))
+
+        prefix_index = self.prefixes.encode_prefix_term_index(prefix)
+        name_index = self.names.encode_name_term_index(name)
+        return term_rows, jelly.RdfIri(prefix_id=prefix_index, name_id=name_index)
+
+    def encode_default_graph(self) -> RowsAnd[jelly.RdfDefaultGraph]:
+        return (), jelly.RdfDefaultGraph()
+
+    def encode_bnode(self, bnode: str) -> RowsAnd[str]:
+        return (), bnode
+
+    def encode_literal(
+        self,
+        *,
+        lex: str,
+        language: str | None = None,
+        datatype: str | None = None,
+    ) -> RowsAnd[jelly.RdfLiteral]:
+        datatype_id = None
+        term_rows: tuple[()] | tuple[jelly.RdfStreamRow] = ()
+
+        if datatype and datatype != options.STRING_DATATYPE_IRI:
+            if self.datatypes.lookup.max_size == 0:
+                msg = (
+                    f"can't encode literal with type {datatype}: "
+                    "datatype lookup cannot be used if disabled "
+                    "(its size was set to 0)"
+                )
+                raise JellyConformanceError(msg)
+            datatype_entry_id = self.datatypes.encode_entry_index(datatype)
+
+            if datatype_entry_id is not None:
+                entry = jelly.RdfDatatypeEntry(id=datatype_entry_id, value=datatype)
+                term_rows = (jelly.RdfStreamRow(datatype=entry),)
+
+            datatype_id = self.datatypes.encode_datatype_term_index(datatype)
+
+        return term_rows, jelly.RdfLiteral(
+            lex=lex,
+            langtag=language,
+            datatype=datatype_id,
+        )
+
+    def encode_any(self, term: object, slot: Slot) -> RowsAndTerm:
+        msg = f"unsupported term type: {type(term)}"
+        raise NotImplementedError(msg)
+
+
+class Slot(str, Enum):
+    """Slots for encoding RDF terms."""
+
+    subject = "s"
+    predicate = "p"
+    object = "o"
+    graph = "g"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+def new_repeated_terms() -> dict[Slot, object]:
+    """Create a new dictionary for repeated terms."""
+    return dict.fromkeys(Slot)
+
+
+def encode_statement(
+    terms: Iterable[object],
+    term_encoder: TermEncoder,
+    repeated_terms: dict[Slot, object],
+) -> tuple[list[jelly.RdfStreamRow], dict[str, Any]]:
+    statement: dict[str, object] = {}
+    rows: list[jelly.RdfStreamRow] = []
+    for slot, term in zip(Slot, terms):
+        if repeated_terms[slot] != term:
+            extra_rows, value = term_encoder.encode_any(term, slot)
+            oneof = term_encoder.TERM_ONEOF_NAMES[type(value)]
+            rows.extend(extra_rows)
+            field = f"{slot}_{oneof}"
+            statement[field] = value
+            repeated_terms[slot] = term
+    return rows, statement
+
+
+def encode_triple(
+    terms: Iterable[object],
+    term_encoder: TermEncoder,
+    repeated_terms: dict[Slot, object],
+) -> list[jelly.RdfStreamRow]:
+    rows, statement = encode_statement(terms, term_encoder, repeated_terms)
+    row = jelly.RdfStreamRow(triple=jelly.RdfTriple(**statement))
+    rows.append(row)
+    return rows
+
+
+def encode_quad(
+    terms: Iterable[object],
+    term_encoder: TermEncoder,
+    repeated_terms: dict[Slot, object],
+) -> list[jelly.RdfStreamRow]:
+    rows, statement = encode_statement(terms, term_encoder, repeated_terms)
+    row = jelly.RdfStreamRow(quad=jelly.RdfQuad(**statement))
+    rows.append(row)
+    return rows
+
+
+def encode_namespace_declaration(
+    name: str,
+    value: str,
+    term_encoder: TermEncoder,
+) -> list[jelly.RdfStreamRow]:
+    [*rows], iri = term_encoder.encode_iri(value)
+    declaration = jelly.RdfNamespaceDeclaration(name=name, value=iri)
+    row = jelly.RdfStreamRow(namespace=declaration)
+    rows.append(row)
+    return rows
+
+
+def encode_options(options: options.StreamOptions) -> jelly.RdfStreamRow:
+    return jelly.RdfStreamRow(
+        options=jelly.RdfStreamOptions(
+            stream_name=options.stream_name,
+            physical_type=options.stream_types.physical_type,
+            generalized_statements=options.generalized_statements,
+            rdf_star=options.rdf_star,
+            max_name_table_size=options.lookup_preset.max_names,
+            max_prefix_table_size=options.lookup_preset.max_prefixes,
+            max_datatype_table_size=options.lookup_preset.max_datatypes,
+            logical_type=options.stream_types.logical_type,
+            version=options.version,
+        )
+    )

pyjelly/serialize/flows.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from collections import UserList
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import ClassVar
+from typing_extensions import override
+
+from pyjelly import jelly
+
+
+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.
+    """
+
+    logical_type: ClassVar[jelly.LogicalStreamType]
+    registry: ClassVar[dict[jelly.LogicalStreamType, type[FrameFlow]]] = {}
+
+    def frame_from_bounds(self) -> jelly.RdfStreamFrame | None:
+        return None
+
+    def to_stream_frame(self) -> jelly.RdfStreamFrame | None:
+        if not self:
+            return None
+        frame = jelly.RdfStreamFrame(rows=self)
+        self.clear()
+        return frame
+
+    def __init_subclass__(cls) -> None:
+        """
+        Register subclasses of FrameFlow with their logical stream type.
+
+        This allows for dynamic dispatch based on the logical stream type.
+        """
+        if cls.logical_type != jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED:
+            cls.registry[cls.logical_type] = cls
+
+
+class ManualFrameFlow(FrameFlow):
+    """
+    Produces frames only when manually requested (never automatically).
+
+    !!! warning
+        All stream rows are kept in memory until `to_stream_frame()` is called.
+        This may lead to high memory usage for large streams.
+
+    Used for non-delimited serialization.
+    """
+
+    logical_type = jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED
+
+
+@dataclass
+class BoundedFrameFlow(FrameFlow):
+    """
+    Produces frames automatically when a fixed number of rows is reached.
+
+    Used for delimited encoding (default mode).
+    """
+
+    logical_type = jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED
+
+    frame_size: int
+    default_frame_size: ClassVar[int] = 250
+
+    def __init__(
+        self,
+        initlist: Iterable[jelly.RdfStreamRow] | None = None,
+        *,
+        frame_size: int | None = None,
+    ) -> None:
+        super().__init__(initlist)
+        self.frame_size = frame_size or self.default_frame_size
+
+    @override
+    def frame_from_bounds(self) -> jelly.RdfStreamFrame | None:
+        if len(self) >= self.frame_size:
+            return self.to_stream_frame()
+        return None
+
+
+# Fallback for unspecified logical types
+FrameFlow.registry[jelly.LOGICAL_STREAM_TYPE_UNSPECIFIED] = BoundedFrameFlow
+
+
+class FlatTriplesFrameFlow(BoundedFrameFlow):
+    logical_type = jelly.LOGICAL_STREAM_TYPE_FLAT_TRIPLES
+
+
+class FlatQuadsFrameFlow(BoundedFrameFlow):
+    logical_type = jelly.LOGICAL_STREAM_TYPE_FLAT_QUADS

pyjelly/serialize/ioutils.py

@@ -0,0 +1,13 @@
+from typing import IO
+
+from google.protobuf.proto import serialize_length_prefixed
+
+from pyjelly import jelly
+
+
+def write_delimited(frame: jelly.RdfStreamFrame, output_stream: IO[bytes]) -> None:
+    serialize_length_prefixed(frame, output_stream)
+
+
+def write_single(frame: jelly.RdfStreamFrame, output_stream: IO[bytes]) -> None:
+    output_stream.write(frame.SerializeToString(deterministic=True))

pyjelly/serialize/lookup.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from collections import OrderedDict
+from dataclasses import dataclass
+from typing import final
+
+
+@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})"
+
+
+@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 not value or self.lookup.max_size == 0:
+            return 0
+        previous_index = self.last_reused_index
+        current_index = self.encode_term_index(value)
+        if value and 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,133 @@
+from __future__ import annotations
+
+from collections.abc import Generator, Iterable
+from typing import Any, ClassVar
+
+from pyjelly import jelly
+from pyjelly.options import StreamOptions
+from pyjelly.serialize.encode import (
+    Slot,
+    TermEncoder,
+    encode_namespace_declaration,
+    encode_options,
+    encode_quad,
+    encode_triple,
+    new_repeated_terms,
+)
+from pyjelly.serialize.flows import FrameFlow, ManualFrameFlow
+
+
+class Stream:
+    physical_type: ClassVar[jelly.PhysicalStreamType]
+    registry: ClassVar[dict[jelly.PhysicalStreamType, type[Stream]]] = {}
+    flow: FrameFlow
+
+    def __init__(
+        self,
+        *,
+        options: StreamOptions,
+        encoder_class: type[TermEncoder],
+        **flow_args: Any,
+    ) -> None:
+        assert options.stream_types.physical_type == self.physical_type
+        self.options = options
+        self.encoder = encoder_class(
+            max_prefixes=options.lookup_preset.max_prefixes,
+            max_names=options.lookup_preset.max_names,
+            max_datatypes=options.lookup_preset.max_datatypes,
+        )
+        flow_class = FrameFlow.registry[self.options.stream_types.logical_type]
+        if not options.delimited:
+            flow_class = ManualFrameFlow
+        self.flow = flow_class(**flow_args)
+        self.repeated_terms = new_repeated_terms()
+        self.enrolled = False
+
+    @staticmethod
+    def from_options(
+        options: StreamOptions,
+        encoder_class: type[TermEncoder] | None = None,
+        **flow_args: Any,
+    ) -> Any:
+        if encoder_class is None:
+            from pyjelly.integrations.rdflib.serialize import RDFLibTermEncoder
+
+            encoder_class = RDFLibTermEncoder
+        stream_class = Stream.registry[options.stream_types.physical_type]
+        return stream_class(
+            options=options,
+            encoder_class=encoder_class,
+            **flow_args,
+        )
+
+    def enroll(self) -> None:
+        if not self.enrolled:
+            self.stream_options()
+            self.enrolled = True
+
+    def stream_options(self) -> None:
+        self.flow.append(encode_options(self.options))
+
+    def namespace_declaration(self, name: str, iri: str) -> None:
+        rows = encode_namespace_declaration(
+            name=name,
+            value=iri,
+            term_encoder=self.encoder,
+        )
+        self.flow.extend(rows)
+
+    def __init_subclass__(cls) -> None:
+        cls.registry[cls.physical_type] = cls
+
+
+class TripleStream(Stream):
+    physical_type = jelly.PHYSICAL_STREAM_TYPE_TRIPLES
+
+    def triple(self, terms: Iterable[object]) -> jelly.RdfStreamFrame | None:
+        new_rows = encode_triple(
+            terms,
+            term_encoder=self.encoder,
+            repeated_terms=self.repeated_terms,
+        )
+        self.flow.extend(new_rows)
+        if frame := self.flow.frame_from_bounds():
+            return frame
+        return None
+
+
+class QuadStream(Stream):
+    physical_type = jelly.PHYSICAL_STREAM_TYPE_QUADS
+
+    def quad(self, terms: Iterable[object]) -> jelly.RdfStreamFrame | None:
+        new_rows = encode_quad(
+            terms,
+            term_encoder=self.encoder,
+            repeated_terms=self.repeated_terms,
+        )
+        self.flow.extend(new_rows)
+        if frame := self.flow.frame_from_bounds():
+            return frame
+        return None
+
+
+class GraphStream(TripleStream):
+    physical_type = jelly.PHYSICAL_STREAM_TYPE_GRAPHS
+
+    def graph(
+        self,
+        graph_id: object,
+        graph: Iterable[Iterable[object]],
+    ) -> Generator[jelly.RdfStreamFrame]:
+        [*graph_rows], graph_node = self.encoder.encode_any(graph_id, Slot.graph)
+        kw_name = f"{Slot.graph}_{self.encoder.TERM_ONEOF_NAMES[type(graph_node)]}"
+        kws: dict[Any, Any] = {kw_name: graph_node}
+        start_row = jelly.RdfStreamRow(graph_start=jelly.RdfGraphStart(**kws))
+        graph_rows.append(start_row)
+        self.flow.extend(graph_rows)
+        for triple in graph:
+            if frame := self.triple(triple):
+                yield frame
+        end_row = jelly.RdfStreamRow(graph_end=jelly.RdfGraphEnd())
+        self.flow.append(end_row)
+        if self.flow.frame_from_bounds():
+            yield self.flow.to_stream_frame()  # type: ignore[misc]

pyjelly-0.1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: pyjelly
+Version: 0.1.0
+Summary: Jelly RDF implementation for Python
+Author-email: Bartosz Sławecki <bartosz@neverblink.eu>, Anastasiya Danilenka <anastasiya@neverblink.eu>
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: protobuf>=5.29.3
+Requires-Dist: rdflib>=7.1.4
+Requires-Dist: typing-extensions>=4.12.2

pyjelly-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+pyjelly/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyjelly/errors.py,sha256=R-xRB4a9S19J9dzAL4a5MCaBwb9ev_kvphGFkQJX6ZU,332
+pyjelly/options.py,sha256=QyGLpHOyNvBSVYYtbLD2rW43gHXRY580NAA17G9dhHs,4045
+pyjelly/_proto/grpc.proto,sha256=3PfcZWqKhUSzP_T-xT-80raUYERr_dXWd8rITzXIqek,1188
+pyjelly/_proto/patch.proto,sha256=gASUm0xDG9J1advNoq_cCsJYxudTbQaiZQBq4oW3kw4,5291
+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=k7cNSFgFXK0_4792eZ-lDRzzSqLI7DFMZmbsPD9SLyE,7474
+pyjelly/integrations/rdflib/serialize.py,sha256=YNwKBD_a4oKNktUQa092UXvmdcu9JYAJDkYRfki2p-w,3940
+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/parse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyjelly/parse/decode.py,sha256=7yfpZ4w8HeXTqWyDROsqfXSaZcCsdnYNhYoRtxRaWEs,8455
+pyjelly/parse/ioutils.py,sha256=FnQNPiDAWLk0IXxUkmVxjsVEjC1y-dBTKKk6lf224SM,2747
+pyjelly/parse/lookup.py,sha256=1AbdZEycLC4tRfh3fgF5hv5PrhwhdWvCUC53iHt-E4c,2193
+pyjelly/serialize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyjelly/serialize/encode.py,sha256=ev8Z7B-ptvch1Xu173lDO3JW3egW-QyzOngDfLDzKsI,6548
+pyjelly/serialize/flows.py,sha256=vezvYeYYumEH0IceebogW4QwM2d1GeOv1yASrJWTTHc,2665
+pyjelly/serialize/ioutils.py,sha256=2_NaadLfHO3jKR1ZV7aK6jQ09sPKBar9iLFHYwourz8,400
+pyjelly/serialize/lookup.py,sha256=vH21uzs7gvjk-Yc0hoSC3_LPsVff86YHuUhikP9djYo,4047
+pyjelly/serialize/streams.py,sha256=0csixgSnGprXhoHOoVimtoPFgt4mqU4Lgv_l6d0EW6g,4247
+pyjelly-0.1.0.dist-info/METADATA,sha256=Kh6HOcK8aLfkSyszqaKOejBbqaI1JrR1gzJ85xfWlr8,348
+pyjelly-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyjelly-0.1.0.dist-info/entry_points.txt,sha256=kUG0p9zso7HpitdMaQaXEj_KSqgOGsL0Ky9ARbecN1g,339
+pyjelly-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyjelly-0.1.0.dist-info/RECORD,,

pyjelly-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyjelly-0.1.0.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