tessl/pypi-rdflib

RDFLib is a Python library for working with RDF, a simple yet powerful language for representing information.

—

Pending

Overview

Eval results

Files

Dataset and Named Graphs

Name: tessl/pypi-rdflib
Author: tessl

RDF 1.1 Dataset implementation for working with collections of named graphs. Provides methods for managing multiple graphs within a single container, supporting the W3C RDF 1.1 Dataset specification.

Capabilities

Dataset - RDF 1.1 Dataset Container

Primary container for multiple named graphs with a default graph.

class Dataset:
    def __init__(self, store: str = 'default', default_union: bool = False, default_graph_base: str = None):
        """
        Create an RDF 1.1 Dataset.
        
        Parameters:
        - store: Store type ('Memory', 'SPARQLStore', etc.)
        - default_union: Whether default graph is union of named graphs
        - default_graph_base: Base URI for default graph
        """
    
    def graph(self, identifier: Node = None) -> Graph:
        """
        Get or create a named graph.
        
        Parameters:
        - identifier: Graph identifier (URIRef or BNode); auto-generated if None
        
        Returns:
        Graph: Named graph instance
        """
    
    def add_graph(self, g: Graph) -> 'Dataset':
        """
        Add an existing graph to the dataset.
        
        Parameters:
        - g: Graph to add
        
        Returns:
        Dataset: Self for method chaining
        """
    
    def remove_graph(self, g: Graph) -> 'Dataset':
        """
        Remove a graph from the dataset.
        
        Parameters:
        - g: Graph to remove
        
        Returns:
        Dataset: Self for method chaining
        """
    
    @property
    def default_graph(self) -> Graph:
        """
        Get the default graph.
        
        Returns:
        Graph: Default graph instance
        """
    
    def named_graphs(self) -> Iterator[Graph]:
        """
        Iterate over named graphs in the dataset.
        
        Returns:
        Iterator: Named graph instances
        """
    
    def contexts(self, triple: Tuple[Node, Node, Node] = None) -> Iterator[Graph]:
        """
        Get contexts (graphs) containing the triple pattern.
        
        Parameters:
        - triple: Triple pattern to match
        
        Returns:
        Iterator: Matching graph contexts
        """
    
    def quads(self, quad: Tuple[Node, Node, Node, Node] = None) -> Iterator[Tuple[Node, Node, Node, Graph]]:
        """
        Iterate over quads (triples with graph context).
        
        Parameters:
        - quad: Quad pattern to match (subject, predicate, object, graph)
        
        Returns:
        Iterator: Matching quads
        """
    
    def add(self, quad: Tuple[Node, Node, Node, Node]):
        """
        Add a quad to the dataset.
        
        Parameters:
        - quad: (subject, predicate, object, graph) tuple
        """
    
    def remove(self, quad: Tuple[Node, Node, Node, Node]):
        """
        Remove quads matching the pattern.
        
        Parameters:
        - quad: Quad pattern (None acts as wildcard)
        """
    
    def parse(self, source, publicID: str = None, format: str = None, location: str = None, file=None, data: str = None, **args):
        """
        Parse RDF data into the dataset.
        
        Parameters:
        - source: Source location (URL, file path, or file-like object)
        - publicID: Logical URI for the document
        - format: RDF format ('trig', 'nquads', etc.)
        - location: Physical location hint
        - file: File-like object
        - data: RDF data as string
        
        Returns:
        Dataset: Self for method chaining
        """
    
    def serialize(self, destination=None, format: str = 'trig', **args) -> str:
        """
        Serialize the dataset to RDF format.
        
        Parameters:
        - destination: Output destination (file path or file-like object)
        - format: Output format ('trig', 'nquads', etc.)
        
        Returns:
        str: Serialized RDF data if no destination specified
        """
    
    def query(self, query_object, processor: str = 'sparql', result: str = 'sparql', initNs: Dict[str, Namespace] = None, initBindings: Dict = None, use_store_provided: bool = True, **kwargs):
        """
        Execute a SPARQL query against the dataset.
        
        Parameters:
        - query_object: Query string or prepared query
        - processor: Query processor to use
        - result: Result format
        - initNs: Initial namespace bindings
        - initBindings: Initial variable bindings
        - use_store_provided: Use store's query capabilities if available
        
        Returns:
        Result: Query results
        """
    
    def update(self, update_object, processor: str = 'sparql', initNs: Dict[str, Namespace] = None, initBindings: Dict = None, use_store_provided: bool = True, **kwargs):
        """
        Execute a SPARQL update against the dataset.
        
        Parameters:
        - update_object: Update string or prepared update
        - processor: Update processor to use
        - initNs: Initial namespace bindings
        - initBindings: Initial variable bindings
        - use_store_provided: Use store's update capabilities if available
        """
    
    def __len__(self) -> int:
        """
        Get total number of quads in dataset.
        
        Returns:
        int: Quad count across all graphs
        """
    
    def __contains__(self, quad: Tuple[Node, Node, Node, Node]) -> bool:
        """
        Check if dataset contains a quad.
        
        Parameters:
        - quad: Quad to check
        
        Returns:
        bool: True if quad exists
        """

Usage Examples

Creating and Managing Datasets

from rdflib import Dataset, Graph, URIRef, Literal
from rdflib.namespace import RDF, FOAF, DCTERMS

# Create a dataset
ds = Dataset()

# Work with the default graph
default = ds.default_graph
default.add((URIRef("http://example.org/person/1"), RDF.type, FOAF.Person))

# Create named graphs
graph1 = ds.graph(URIRef("http://example.org/graph/personal"))
graph2 = ds.graph(URIRef("http://example.org/graph/work"))

# Add data to named graphs
graph1.add((URIRef("http://example.org/person/1"), FOAF.name, Literal("John Doe")))
graph1.add((URIRef("http://example.org/person/1"), FOAF.age, Literal(30)))

graph2.add((URIRef("http://example.org/person/1"), FOAF.title, Literal("Software Engineer")))
graph2.add((URIRef("http://example.org/person/1"), FOAF.organization, Literal("TechCorp")))

Querying Datasets with SPARQL

from rdflib import Dataset

ds = Dataset()
# ... populate with data ...

# Query across all graphs
query = """
    SELECT ?name ?title ?graph WHERE {
        GRAPH ?graph {
            ?person foaf:name ?name .
            OPTIONAL { ?person foaf:title ?title }
        }
    }
"""

results = ds.query(query)
for row in results:
    print(f"Name: {row.name}, Title: {row.title}, Graph: {row.graph}")

# Query specific graph
specific_query = """
    SELECT ?name WHERE {
        GRAPH <http://example.org/graph/personal> {
            ?person foaf:name ?name
        }
    }
"""

results = ds.query(specific_query)

Working with Quads

from rdflib import Dataset, URIRef, Literal
from rdflib.namespace import FOAF

ds = Dataset()

# Add quads directly
person = URIRef("http://example.org/person/1")
graph_uri = URIRef("http://example.org/graph/data")

ds.add((person, FOAF.name, Literal("Alice"), graph_uri))
ds.add((person, FOAF.age, Literal(25), graph_uri))

# Iterate over quads
for s, p, o, g in ds.quads():
    print(f"Subject: {s}, Predicate: {p}, Object: {o}, Graph: {g}")

# Pattern matching with quads
for s, p, o, g in ds.quads((person, None, None, None)):
    print(f"Person property: {p} = {o} in graph {g}")

Parsing and Serializing Datasets

from rdflib import Dataset

ds = Dataset()

# Parse dataset formats
ds.parse("data.trig", format="trig")      # TriG format
ds.parse("data.nq", format="nquads")     # N-Quads format

# Serialize to dataset formats
trig_data = ds.serialize(format="trig")
nquads_data = ds.serialize(format="nquads")

# Save to file
ds.serialize("output.trig", format="trig")

Managing Named Graphs

from rdflib import Dataset, Graph, URIRef
from rdflib.namespace import FOAF

ds = Dataset()

# Create and populate a graph
graph_uri = URIRef("http://example.org/graph/people")
people_graph = ds.graph(graph_uri)
people_graph.add((URIRef("http://example.org/person/1"), FOAF.name, Literal("John")))

# Add an existing graph
external_graph = Graph()
external_graph.add((URIRef("http://example.org/person/2"), FOAF.name, Literal("Jane")))
external_graph.identifier = URIRef("http://example.org/graph/external")
ds.add_graph(external_graph)

# Iterate over named graphs
for graph in ds.named_graphs():
    print(f"Graph: {graph.identifier}")
    for triple in graph:
        print(f"  {triple}")

# Remove a graph
ds.remove_graph(people_graph)

Dataset with Union Default Graph

from rdflib import Dataset, URIRef, Literal
from rdflib.namespace import FOAF

# Create dataset with union default graph
ds = Dataset(default_union=True)

# Add data to named graphs
graph1 = ds.graph(URIRef("http://example.org/graph/1"))
graph1.add((URIRef("http://example.org/person/1"), FOAF.name, Literal("Alice")))

graph2 = ds.graph(URIRef("http://example.org/graph/2"))
graph2.add((URIRef("http://example.org/person/2"), FOAF.name, Literal("Bob")))

# Query default graph sees union of named graphs
query = """
    SELECT ?name WHERE {
        ?person foaf:name ?name
    }
"""

results = ds.default_graph.query(query)
for row in results:
    print(f"Name from union: {row.name}")

SPARQL Updates with Datasets

from rdflib import Dataset

ds = Dataset()

# SPARQL update with named graphs
update = """
    PREFIX foaf: <http://xmlns.com/foaf/0.1/>
    
    INSERT DATA {
        GRAPH <http://example.org/graph/people> {
            <http://example.org/person/1> foaf:name "John Doe" ;
                                         foaf:age 30 .
        }
    }
"""

ds.update(update)

# Move data between graphs
move_update = """
    PREFIX foaf: <http://xmlns.com/foaf/0.1/>
    
    DELETE {
        GRAPH <http://example.org/graph/people> {
            ?person foaf:age ?age
        }
    }
    INSERT {
        GRAPH <http://example.org/graph/demographics> {
            ?person foaf:age ?age
        }
    }
    WHERE {
        GRAPH <http://example.org/graph/people> {
            ?person foaf:age ?age
        }
    }
"""

ds.update(move_update)

Install with Tessl CLI