pyjelly 0.5.0__tar.gz → 0.5.2__tar.gz

{pyjelly-0.5.0 → pyjelly-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyjelly
-Version: 0.5.0
+Version: 0.5.2
 Summary: Jelly-RDF implementation for Python
 Project-URL: Homepage, https://w3id.org/jelly/pyjelly
 Project-URL: Documentation, https://w3id.org/jelly/pyjelly
@@ -29,7 +29,6 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Requires-Dist: protobuf>=6.30.0
-Requires-Dist: pytest-cov>=6.2.1
 Requires-Dist: typing-extensions>=4.12.2
 Provides-Extra: rdflib
 Requires-Dist: rdflib>=7.1.4; extra == 'rdflib'

{pyjelly-0.5.0 → pyjelly-0.5.2}/codecov.yml

@@ -1,4 +1,4 @@
 ignore:
   - "docs"
   - "tests"
-  - "examples"
+  - "examples"

{pyjelly-0.5.0 → pyjelly-0.5.2}/docs/examples/neo4j_integration/01_rdflib_neo4j_parse_grouped.py

@@ -11,7 +11,7 @@ aura_db_uri = "aura_db_uri"
 aura_db_username = "neo4j"
 aura_db_pwd = "aura_db_pwd"
 
-# Prepare the authentication data to the Aura database
+# Prepare the authentication data to the AuraDB
 auth_data = {
     "uri": aura_db_uri,
     "database": "neo4j",
@@ -19,7 +19,7 @@ auth_data = {
     "pwd": aura_db_pwd,
 }
 
-# Prepare the configuration for neo4j store object
+# Prepare the configuration for Neo4jStore object
 config = Neo4jStoreConfig(
     auth_data=auth_data,
     handle_vocab_uri_strategy=HANDLE_VOCAB_URI_STRATEGY.IGNORE,

{pyjelly-0.5.0 → pyjelly-0.5.2}/docs/examples/networkx_integration/01_parse_calculate_visualize.py

@@ -17,11 +17,10 @@ nx_g = rdflib_to_networkx_graph(rdf_g)
 # Example calculation, get the number of connected components in a graph
 num_components = nx.number_connected_components(nx_g)
 
-# Example calculation, get top 5 objects with highest degrees, something simple in NetworkX
+# Example calculation, get top 5 objects with highest degrees, simple in NetworkX
 top5 = sorted(nx_g.degree, key=lambda x: x[1], reverse=True)[:5]
 
-# Example calculation, shortest path between two nodes
-# Provide two example nodes in a graph
+# Example calculation, shortest path between two nodes (provided at least two nodes)
 source, target = list(nx_g.nodes)[0], list(nx_g.nodes)[-1]
 path = nx.shortest_path(nx_g, source=source, target=target)
 

{pyjelly-0.5.0 → pyjelly-0.5.2}/docs/getting-started.md

@@ -1,25 +1,27 @@
 # Getting started
 
-This guide shows how to install pyjelly and prepare your environment for use with RDFLib.
+This guide walks you through installing and working with pyjelly and RDFLib.
 
 ## Installation (with RDFLib)
 
 Install pyjelly from PyPI:
 
-```
+```bash
 pip install pyjelly[rdflib]
 ```
 
-pyjelly requires **Python 3.9** or newer and works on all major platforms (Linux, macOS, Windows).
+### Requirements
 
+- Python 3.9 or newer  
+- Linux, macOS, or Windows
 
 ## Usage with RDFLib
 
-Once installed, pyjelly integrates with RDFLib automatically. You can immediately serialize and parse `.jelly` files using the standard RDFLib API.
+Once you install pyjelly, it integrates automatically with RDFLib through standard RDFLib API.
 
 ### Serializing a graph
 
-To serialize a graph to the Jelly format:
+To serialize a graph to the Jelly format see:
 
 {{ code_example('rdflib/01_serialize.py') }}
 
@@ -27,7 +29,7 @@ This creates a [delimited Jelly stream]({{ proto_link("user-guide/#delimited-vs-
 
 ### Parsing a graph
 
-To load RDF data from a `.jelly` file:
+To load RDF data from a `.jelly` file see:
 
 {{ code_example('rdflib/02_parse.py') }}
 
@@ -37,47 +39,38 @@ RDFLib will reconstruct the graph from the Jelly file.
 
 You can process a Jelly stream as a stream of graphs. A Jelly file consists of "frames" (batches of statements) – we can load each frame as a separate RDFLib graph.
 
-In this example, we use a [dataset of weather measurements](https://w3id.org/riverbench/datasets/lod-katrina/dev), which is an RDF graph stream. We count the number of triples in each graph:
+In this example, we use a [dataset of weather measurements](https://w3id.org/riverbench/datasets/lod-katrina/dev). We count the number of triples in each graph:
 
 {{ code_example('rdflib/04_parse_grouped.py') }}
 
-Because `parse_jelly_grouped` returns a generator, each iteration receives **one** graph, keeping memory usage bounded to the current frame. So, large datasets and live streams can be processed efficiently.
+Each iteration receives only **one** graph, allowing for processing large datasets efficiently, without exhausting memory.
 
 ### Parsing a stream of triples
 
 You can also process a Jelly stream as a flat stream of triples.
 
-In this more complex example, we look through a fragment of Denmark's OpenStreetMap to find all city names:
+We look through a fragment of Denmark's OpenStreetMap to find all city names:
 
 {{ code_example('rdflib/05_parse_flat.py') }}
 
-`parse_jelly_flat` returns a generator of stream events (i.e., statements parsed). This allows you to efficiently process the file triple-by-triple and build custom aggregations from the stream.
+`parse_jelly_flat` returns a generator of stream events (i.e., statements parsed). This case allows you to efficiently process the file triple-by-triple and build custom aggregations from the stream.
 
 ### Serializing a stream of graphs
 
-If you have a generator object containing graphs, you can easily serialize it into the Jelly format, like in the following example: 
+If you have a generator object containing graphs, you can easily serialize it into the Jelly format: 
 
 {{ code_example('rdflib/06_serialize_grouped.py')}}
 
-This method allows for transmitting logically grouped data, preserving their original division.
+This method allows for transmitting logically grouped data, preserving their original division. 
 For more precise control over frame serialization you can use [lower-level API](api.md)
 
 ### Serializing a stream of statements
 
-If you have a generator object containing statements, you can easily serialize it into the Jelly format, like in the following example: 
+If you have a generator object containing statements, you can easily serialize it into the Jelly format: 
 
 {{ code_example('rdflib/07_serialize_flat.py')}}
 
-The flat method transmits the data as a continuous sequence of individual statements (i.e., triples or quads), keeping the simplicity and order of the data.
-For more precise control over frame serialization you can use [lower-level API](api.md)
-
-### Serializing a stream of graphs
-
-If you have a generator object containing graphs, you can easily serialize it into the Jelly format, like in the following example: 
-
-{{ code_example('rdflib/06_serialize_grouped.py')}}
-
-This method allows for transmitting logically grouped data, preserving their original division.
+The flat method transmits the data as a continuous sequence of statements, keeping it simple and ordered.
 For more precise control over frame serialization you can use [lower-level API](api.md)
 
 ### File extension support

{pyjelly-0.5.0 → pyjelly-0.5.2}/docs/index.md

@@ -2,19 +2,18 @@
 
 [![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** is a Python implementation of [Jelly]({{ proto_link("") }}), a high-performance binary serialization format and streaming protocol for RDF knowledge graphs. It works great with [rdflib](getting-started.md).
+**pyjelly** is a Python implementation of [Jelly]({{ proto_link("") }}), a high-performance binary serialization format and streaming protocol for RDF knowledge graphs. It works great with [RDFLib](getting-started.md).
 
 ## Features
 
 - **Fast reading and writing** of RDF knowledge graphs in the [Jelly format](http://w3id.org/jelly)
-- **Seamless integration with [rdflib](https://rdflib.readthedocs.io/)**
+- **Seamless integration with [RDFLib](https://rdflib.readthedocs.io/)**
 - **Stream processing support** for large datasets or streams of many RDF graphs/datasets
 
 ## Documentation
 
 - **[Getting started](getting-started.md)**
 - **[Overview and supported features](overview.md)**
-- **[Integration with Python RDF Tools](external-integration.md)**
 - **[API reference](api.md)**
 - **[Contributing](contributing/index.md)** – how to report issues, contribute code, and request features
 

pyjelly-0.5.2/docs/networkx-integration.md

@@ -0,0 +1,35 @@
+# NetworkX
+
+NetworkX is a Python package that represents complex networks as graphs and allows for their manipulation.
+
+Install the following libraries:
+
+```bash
+pip install pyjelly[rdflib] networkx==3.2.1 matplotlib==3.9.4
+```
+
+Below there are few useful examples to follow.
+
+## Parse graph, show it
+
+To load graph form a `.jelly` file, and (optionally) calculate some practical graph characteristics, see:
+
+{{ code_example('networkx_integration/01_parse_calculate_visualize.py') }}
+
+which converts an RDFLib graph to NetworkX, computes key metrics and visualizes it.
+
+## Serialize NetworkX graph
+
+This example shows how to write a NetworkX graph to a Jelly file.:
+
+{{ code_example('networkx_integration/02_serialize.py') }}
+
+which converts NetworkX graph into an RDFLib insance and serializes it.
+
+## Related sources
+
+To get more information, see the following:
+
+- [NetworkX examples](https://networkx.org/documentation/stable/auto_examples/index.html)
+- [NetworkX repository (github)](https://github.com/networkx/networkx)
+- [RDFLib external graph integration](https://rdflib.readthedocs.io/en/7.1.0/_modules/rdflib/extras/external_graph_libs.html)

{pyjelly-0.5.0 → pyjelly-0.5.2}/docs/overview.md

@@ -18,7 +18,7 @@ With Jelly, you can transmit both flat and structured streams of triples, quads,
 
 pyjelly supports all [physical stream types]({{ proto_link("specification/reference/#physicalstreamtype") }}): `TRIPLES`, `QUADS` and `GRAPHS`.
 
-See the full [stream type matrix]({{ proto_link("serialization/#consistency-with-physical-stream-types") }}) for an overview of valid combinations.
+See the full [stream type matrix]({{ proto_link("specification/serialization/#consistency-with-physical-stream-types") }}) for an overview of valid combinations.
 
 ### Conformance to the Jelly specification
 
@@ -36,3 +36,10 @@ Use cases for pyjelly include:
     - pyjelly is fully streaming, so it can handle large datasets without loading everything into memory at once.
     - We are working on support for pandas and other data science libraries – stay tuned for updates!
 - **Database dumps and bulk loads** – quickly read and write large RDF datasets with Jelly, reducing storage space and improving database maintenance tasks.
+
+## pyjelly integration with external libraries
+
+To learn how to use popular third-party libraries that connect with RDFLib, please see:
+
+- **[RDFLib-Neo4j integration](rdflib-neo4j-integration.md)**
+- **[NetworkX integration](networkx-integration.md)**

pyjelly-0.5.2/docs/rdflib-neo4j-integration.md

@@ -0,0 +1,24 @@
+# RDFLib-Neo4j
+
+RDFLib-Neo4j lets you import RDF triples into Neo4j via the RDFLib API.
+
+Install the following library:  
+
+```bash
+pip install pyjelly[rdflib] rdflib-neo4j
+```
+
+## Parsing data from a Jelly file into Neo4j
+
+To parse data from a `.jelly` file into the Neo4j database, use the following example (insert your own credentials to AuraDB):
+
+{{ code_example('neo4j_integration/01_rdflib_neo4j_parse_grouped.py') }}
+
+which inserts your data into your AuraDB database.
+
+## Related sources
+
+For more information, visit:
+
+- [RDFLib-Neo4j (GitHub)](https://github.com/neo4j-labs/rdflib-neo4j)
+- [Neo4j Labs: RDFLib-Neo4j](https://neo4j.com/labs/rdflib-neo4j/)

{pyjelly-0.5.0 → pyjelly-0.5.2}/mkdocs.yml

@@ -117,14 +117,16 @@ extra:
       name: Community Discord server
 
 nav:
-  - Home: "index.md"
-  - Getting started: "getting-started.md"
-  - Overview and supported features: "overview.md"
-  - Integration with Python RDF Tools: "external-integration.md"
+  - Home : "index.md"
+  - User guide:
+      - Getting started (RDFLib): "getting-started.md"
+      - Overview and supported features: "overview.md"
+      - Neo4j: "rdflib-neo4j-integration.md"
+      - NetworkX: "networkx-integration.md"
   - API reference: "api.md"
   - Contributing:
       - "contributing/index.md"
       - Code of conduct: "contributing/code_of_conduct.md"
-  - Changelog: "https://github.com/Jelly-RDF/pyjelly/releases"
+  - Releases: "https://github.com/Jelly-RDF/pyjelly/releases"
   - Licensing and citation: "https://w3id.org/jelly/dev/licensing"
   - Back to main Jelly docs ↩: "https://w3id.org/jelly/"

{pyjelly-0.5.0 → pyjelly-0.5.2}/pyjelly/options.py

@@ -76,6 +76,12 @@ class StreamTypes:
         )
 
     def __repr__(self) -> str:
+        """
+        Return the representation of StreamTypes.
+
+        >>> repr(StreamTypes(9999, 8888))
+        'StreamTypes(9999, 8888)'
+        """
         with suppress(ValueError):
             physical_type_name = jelly.PhysicalStreamType.Name(self.physical_type)
             logical_type_name = jelly.LogicalStreamType.Name(self.logical_type)

{pyjelly-0.5.0 → pyjelly-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyjelly"
-version = "0.5.0"
+version = "0.5.2"
 readme = "README.md"
 description = "Jelly-RDF implementation for Python"
 authors = [
@@ -33,7 +33,6 @@ keywords = ["RDF", "Knowledge graph", "Jelly", "Serialization format"]
 license = "Apache-2.0"
 dependencies = [
     "protobuf>=6.30.0",
-    "pytest-cov>=6.2.1",
     "typing-extensions>=4.12.2", # revisit after 3.13 is older
 ]
 
@@ -65,6 +64,7 @@ test = [
     "hypothesis>=6.131.0",
     "inline-snapshot>=0.20.8",
     "pytest>=8.3.4",
+    "pytest-cov>=6.2.1",
     "pytest-accept>=0.1.12",
     "pytest-mock>=3.14.0",
     "pytest-subtests>=0.14.1",

{pyjelly-0.5.0 → pyjelly-0.5.2}/submodules/protobuf/test/rdf/from_jelly/manifest.ttl

@@ -877,11 +877,15 @@ BASE           <https://w3id.org/jelly/dev/tests/rdf/from_jelly/>
     mf:result <graphs_rdf_star/pos_006/out_000.nq> .
 
 <graphs_rdf_star/pos_007> a jellyt:TestPositive, jellyt:TestRdfFromJelly ;
-    mf:name "Three (3) frames with a set of quads with quoted triples  Prefix table enabled." ;
+    mf:name "Three (3) frames with a set of quads with quoted triples. Prefix table enabled." ;
     rdft:approval rdft:Proposed ;
     mf:requires jellyt:requirementPhysicalTypeGraphs, jellyt:requirementRdfStar ;
     mf:action <graphs_rdf_star/pos_007/in.jelly> ;
-    mf:result <graphs_rdf_star/pos_007/out_000.nq> .
+    mf:result (
+        <graphs_rdf_star/pos_007/out_000.nq>
+        <graphs_rdf_star/pos_007/out_001.nq>
+        <graphs_rdf_star/pos_007/out_002.nq>
+    ).
 
 <quads_rdf_star_generalized/neg_001> a jellyt:TestNegative, jellyt:TestRdfFromJelly ;
     mf:name "Single frame, s_triple_term is missing a p_literal on the first nesting level, p_literal on the deeper levels repeats. Repeated terms are prohibited in quoted triples." ;

{pyjelly-0.5.0 → pyjelly-0.5.2}/tests/unit_tests/test_options.py

@@ -3,10 +3,18 @@ from __future__ import annotations
 from unittest.mock import Mock
 
 import pytest
+from _pytest.monkeypatch import MonkeyPatch
 
+import pyjelly.options as op
 from pyjelly import jelly
-from pyjelly.errors import JellyAssertionError
-from pyjelly.options import StreamParameters, StreamTypes
+from pyjelly.errors import JellyAssertionError, JellyConformanceError
+from pyjelly.options import (
+    MIN_NAME_LOOKUP_SIZE,
+    MIN_VERSION,
+    LookupPreset,
+    StreamParameters,
+    StreamTypes,
+)
 from pyjelly.parse.decode import options_from_frame
 
 
@@ -151,3 +159,28 @@ def test_stream_parameters(generalized_statements: int, rdf_star: int) -> None:
     )
     assert params.generalized_statements == mock_options.generalized_statements
     assert params.rdf_star == mock_options.rdf_star
+
+
+def test_lookup_preset_validation() -> None:
+    with pytest.raises(JellyConformanceError):
+        LookupPreset(max_names=MIN_NAME_LOOKUP_SIZE - 1)
+    p = LookupPreset.small()
+    assert (p.max_names, p.max_prefixes, p.max_datatypes) == (128, 32, 32)
+
+
+def test_stream_parameters_version() -> None:
+    s1 = StreamParameters(namespace_declarations=False)
+    assert s1.version == MIN_VERSION
+    s2 = StreamParameters(namespace_declarations=True)
+    assert s2.version == 2
+
+
+def test_stream_options_invalid_version(monkeypatch: MonkeyPatch) -> None:
+    monkeypatch.setattr(op, "MIN_VERSION", 10)
+    monkeypatch.setattr(op, "MAX_VERSION", 5)
+
+    with pytest.raises(JellyConformanceError) as excinfo:
+        StreamParameters(namespace_declarations=True)
+
+    msg = str(excinfo.value)
+    assert "Version must be between 10 and 5" in msg

{pyjelly-0.5.0 → pyjelly-0.5.2}/uv.lock

@@ -1373,11 +1373,10 @@ wheels = [
 
 [[package]]
 name = "pyjelly"
-version = "0.5.0"
+version = "0.5.2"
 source = { editable = "." }
 dependencies = [
     { name = "protobuf" },
-    { name = "pytest-cov" },
     { name = "typing-extensions" },
 ]
 
@@ -1418,6 +1417,7 @@ test = [
     { name = "inline-snapshot" },
     { name = "pytest" },
     { name = "pytest-accept" },
+    { name = "pytest-cov" },
     { name = "pytest-mock" },
     { name = "pytest-subtests" },
     { name = "pytest-sugar" },
@@ -1429,7 +1429,6 @@ types = [
 [package.metadata]
 requires-dist = [
     { name = "protobuf", specifier = ">=6.30.0" },
-    { name = "pytest-cov", specifier = ">=6.2.1" },
     { name = "rdflib", marker = "extra == 'rdflib'", specifier = ">=7.1.4" },
     { name = "typing-extensions", specifier = ">=4.12.2" },
 ]
@@ -1463,6 +1462,7 @@ test = [
     { name = "inline-snapshot", specifier = ">=0.20.8" },
     { name = "pytest", specifier = ">=8.3.4" },
     { name = "pytest-accept", specifier = ">=0.1.12" },
+    { name = "pytest-cov", specifier = ">=6.2.1" },
     { name = "pytest-mock", specifier = ">=3.14.0" },
     { name = "pytest-subtests", specifier = ">=0.14.1" },
     { name = "pytest-sugar", specifier = ">=1.0.0" },

pyjelly-0.5.0/docs/external-integration.md

@@ -1,69 +0,0 @@
-# Pyjelly integration with external libraries
-
-This section describes how to integrate useful third‑party libraries that utilize RDFLib.  
-In order to proceed with the content of the document, one should be acquainted with the [getting-started.md](getting-started.md) file.
-
-## Neo4j - rdflib
-
-The Neo4j RDFLib library is a Python plugin that lets you use RDFLib’s API to parse RDF triples directly in a Neo4j graph database.  
-Because Neo4j integrates well with the baseline RDFLib objects, which is also true for pyjelly, both libraries can be easily combined.  
-
-In further steps we will exemplify the integration, however first, (in our pyjelly environment) we should install rdflib-neo4j:  
-```
-pip install rdflib-neo4j
-```
-
-For more information, one should visit the following references found on the rdflib-neo4j original sources, which formed the base of
-the following document:  
-    - [github.com/neo4j-labs/rdflib-neo4j](https://github.com/neo4j-labs/rdflib-neo4j)  
-    - [neo4j.com/labs/rdflib-neo4j/](https://neo4j.com/labs/rdflib-neo4j/)  
-
-### Configure Your AuraDB Connection
-
-Before running the example code, make sure to provide your own credentials to the AuraDB instance listed below:
-```
-AURA_DB_URI
-AURA_DB_USERNAME
-AURA_DB_PWD
-```
-
-### Parsing data into neo4j from a jelly file
-
-To parse data into the neo4j database from `.jelly` file use the following example:
-
-{{ code_example('neo4j_integration/01_rdflib_neo4j_parse_grouped.py') }}
-
-which parses the data from `.jelly` file into the user's AuraDB database.
-
-## NetworkX
-
-NetworkX is a Python package for the creation, manipulation, and analysis of the structure, dynamics, and functions of networks represented as graphs.
-Due to its seamless integration with RDFlib and PyJelly via its conversion utilities, these libraries can be easily combined for graph analysis and transformation tasks.
-
-To successfully go through the use cases, one should primarily install the following libraries:
-```
-pip install networkx==3.2.1 matplotlib==3.9.4
-```
-
-To get more information about the NetworkX itself, see the package's documentation and other useful utilities:  
-    - [networkx.org/documentation/stable/auto_examples](https://networkx.org/documentation/stable/auto_examples/index.html)  
-    - [rdflib.readthedocs.io/en/7.1.0/_modules/rdflib/extras/external_graph_libs.html](https://rdflib.readthedocs.io/en/7.1.0/_modules/rdflib/extras/external_graph_libs.html)  
-    - [github.com/networkx/networkx](https://github.com/networkx/networkx)  
-
-In the following sub-sections, we will describe a few useful and baseline use cases for performing integration between the modules.
-
-### Parse graph into NetworkX object, visualize it, calculate useful graph-based characteristics
-
-To load data into a NetworkX object, starting from a `.jelly` file, and (optionally) calculate some practical graph characteristics, one can look into the example:
-
-{{ code_example('networkx_integration/01_parse_calculate_visualize.py') }}
-
-which loads the data from RDFLib graph into equivalent NetworkX graph, performs computation of useful graph theory metrics and visualizes the graph.
-
-### Transform and serialize NetworkX graph
-
-To transform a NetworkX graph into RDFLib graph and perform its serialization into the `.jelly` format, look into the example:
-
-{{ code_example('networkx_integration/02_serialize.py') }}
-
-Which converts an example-defined NetworkX graph into RDFLib graph and performs its serialization.