pyjelly 0.5.0__tar.gz → 0.5.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyjelly
-Version: 0.5.0
+Version: 0.5.1
 Summary: Jelly-RDF implementation for Python
 Project-URL: Homepage, https://w3id.org/jelly/pyjelly
 Project-URL: Documentation, https://w3id.org/jelly/pyjelly

{pyjelly-0.5.0 → pyjelly-0.5.1}/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.1}/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.1}/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 pyjelly, setting up your environment for RDFLib, and using the library's core features.
 
 ## 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 automatically integrates with RDFLib. You can immediately serialize and parse `.jelly` files using the 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') }}
 
@@ -68,7 +70,7 @@ If you have a generator object containing statements, you can easily serialize i
 
 {{ 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.
+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

{pyjelly-0.5.0 → pyjelly-0.5.1}/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.1/docs/networkx-integration.md

@@ -0,0 +1,34 @@
+# 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.0 → pyjelly-0.5.1}/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.1/docs/rdflib-neo4j-integration.md

@@ -0,0 +1,23 @@
+# 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.

{pyjelly-0.5.0 → pyjelly-0.5.1}/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"
+      - RDFLib-Neo4j integration: "rdflib-neo4j-integration.md"
+      - NetworkX integration: "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/"
+  - Back to main Jelly docs ↩: "https://w3id.org/jelly/"

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyjelly"
-version = "0.5.0"
+version = "0.5.1"
 readme = "README.md"
 description = "Jelly-RDF implementation for Python"
 authors = [

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

@@ -1373,7 +1373,7 @@ wheels = [
 
 [[package]]
 name = "pyjelly"
-version = "0.5.0"
+version = "0.5.1"
 source = { editable = "." }
 dependencies = [
     { name = "protobuf" },

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.