pchampin

#!/usr/bin/bash
# dependency: https://github.com/pchampin/sophia-cli

sop parse "$1" --base x-dummy-base: ! canonicalize

# NB: we use a dummy base so that the result does not depend on the location of "$1".
# Indeed, I use this script primarily to re-process RDF files before git diff,
# so the different copies of the *same* files should not be considered to have different bases.
#
# Snippet from by ~/.gitconfig file

pchampin

#!/bin/bash

# usage: rdfdiff <file1> <file2> [git-diff options...]
#  set base URI with the BASE environment variable, if necessary

# requires a "release" build of sophia examples 'parse' and 'canonicalize'
# in a clone of https://github.com/pchampin/sophia_rs
# indicated by SOPHIA_HOME (defaults to ~/dev/sophia_rs)
#
# To produce them, run

pchampin

@prefix s: <http://schema.org/>.

# simple (unqualified) statement

:dr_strangelove a s:Movie ;
  s:actor :peter_sellers.


# RDF-star with "ocurrence" nodes

pchampin

#!/usr/bin/env python
#
# Command-line JSON-LD processor based on PyLD
#
# Copyright © 2021-2022 Pierre-Antoine Champin <[email protected]>

import argparse
import json
import sys
from urllib.parse import urljoin, urlsplit

pchampin

#!/usr/bin/env python3
"""
This script checks different triple stores implementing RDF*,
to see how opaque/transparent are the terms used in embedded triples.
"""
from sys import argv, stderr
import base64
try:
    import requests
except:

pchampin

@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
@prefix math: <http://www.w3.org/2000/10/swap/math#>.
@prefix : <#>.

{ (?lst 1) :memberAt ?elt } <= { ?lst rdf:first ?elt. }.
{ (?lst ?i) :memberAt ?elt } <= { ?lst rdf:first ?elt. ?i math:equalTo 1. }.
{ (?lst ?i) :memberAt ?elt } <= { ?lst rdf:rest ?rest. (?rest ?j) :memberAt ?elt. (?j 1) math:sum ?i. }.

{ ((41) 1)   :memberAt 41 } => { :TEST :PASS 1 }.
{ ((41) 1.0) :memberAt 41 } => { :TEST :PASS 2 }.

pchampin

//! This is an experiment on how to get rid of lifetime parameters in
//! Sopghia's Graph and Dataset traits. It demonstrates the general idea
//! on a simplified version of Triple and Graph.
//! 
//! Graph iterators no longer return Graph::Triple's,
//! they return a safe abstraction around it: GuardedTRiple<'a, Graph::Triple>.
//! 
//! Graph::Triple itself can be one of several options:
//! * T (where T implements Triple)
//! * *const T (where T implements Triple)

pchampin

from collections import namedtuple
from timeit import default_timer
from itertools import repeat

class Classic(object):
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

pchampin

from rdflib import BNode, URIRef
from rdflib.plugins.stores.sparqlstore import SPARQLUpdateStore, _node_to_sparql, _node_from_result, SPARQL_NS
from uuid import uuid4

def _virtuoso_compatible_generator():
    return unicode(uuid4().int % 2**61)

# monkey patch BNode to make it virtuoso compatible
BNode.__new__.func_defaults = (None, _virtuoso_compatible_generator, 'b')

pchampin

/* global Promise */

/**
 * An IterablePromise is used to combine the ease of use of loops,
 * with the power of Promises.
 * 
 * Assume you want to apply an asynchronous function process(),
 * returning a Promise, to each item of an array ``a``,
 * but wait for each element to be processed before processing the next one.
 * You would do it like this: