pyjelly 0.5.1__tar.gz → 0.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyjelly
-Version: 0.5.1
+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.1 → pyjelly-0.5.2}/codecov.yml

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

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

@@ -1,6 +1,6 @@
 # Getting started
 
-This guide walks you through installing pyjelly, setting up your environment for RDFLib, and using the library's core features.
+This guide walks you through installing and working with pyjelly and RDFLib.
 
 ## Installation (with RDFLib)
 
@@ -17,7 +17,7 @@ pip install pyjelly[rdflib]
 
 ## Usage with RDFLib
 
-Once you install pyjelly, it automatically integrates with RDFLib. 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
 
@@ -39,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 its the simplicity and order.
-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.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.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.1 → pyjelly-0.5.2}/mkdocs.yml

@@ -121,12 +121,12 @@ nav:
   - User guide:
       - Getting started (RDFLib): "getting-started.md"
       - Overview and supported features: "overview.md"
-      - RDFLib-Neo4j integration: "rdflib-neo4j-integration.md"
-      - NetworkX integration: "networkx-integration.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"
   - 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/"
+  - Back to main Jelly docs ↩: "https://w3id.org/jelly/"

{pyjelly-0.5.1 → 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.1 → pyjelly-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyjelly"
-version = "0.5.1"
+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.1 → 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.1 → 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.1 → pyjelly-0.5.2}/uv.lock

@@ -1373,11 +1373,10 @@ wheels = [
 
 [[package]]
 name = "pyjelly"
-version = "0.5.1"
+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.1/docs/networkx-integration.md

@@ -1,34 +0,0 @@
-# NetworkX
-
-NetworkX is a Python package that represents networks as graphs and allows for their creation, manipulation, and analysis.
-Due to its conversion utilities, it integrates seamlessly with RDFLib and pyjelly, so you can easily integrate these libraries.
-
-Install the following libraries:
-
-```bash
-pip install networkx==3.2.1 matplotlib==3.9.4
-```
-
-To get more information, see the package's documentation and other useful utilities:
-
-- [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)
-
-In the following sub-sections, we will describe a few useful and baseline use cases for performing integration between the modules.
-
-## Parse graph, 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, see 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 an 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 an RDFLib graph and performs its serialization.

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

@@ -1,23 +0,0 @@
-# RDFLib-Neo4j
-
-The RDFLib-Neo4j library is a Python plugin that lets you use RDFLib’s API to parse RDF triples directly into a Neo4j graph database.  
-Because Neo4j integrates well with the baseline RDFLib objects, which is also true for pyjelly, you can easily use both libraries.  
-
-Install the following library:  
-
-```bash
-pip install rdflib-neo4j
-```
-
-For more information, visit the following references from the RDFLib-Neo4j original sources:
-
-- [RDFLib-Neo4j (GitHub)](https://github.com/neo4j-labs/rdflib-neo4j)
-- [Neo4j Labs: RDFLib-Neo4j](https://neo4j.com/labs/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 with your own credentials to AuraDB:
-
-{{ code_example('neo4j_integration/01_rdflib_neo4j_parse_grouped.py') }}
-
-which parses the data from a `.jelly` file into your AuraDB database.