hardf
0.5.0
hardf é uma biblioteca PHP 7.1+ que permite lidar com Linked Data (RDF). Oferece:
Tanto o analisador quanto o serializador possuem suporte para streaming .
Esta biblioteca é uma porta de N3.js para PHP
Usamos a representação tripla em PHP portado da biblioteca NodeJS N3.js. Verifique https://github.com/rdfjs/N3.js/tree/v0.10.0#triple-representation para obter mais informações
Propositalmente, focamos no desempenho e não na facilidade de uso do desenvolvedor. Portanto, implementamos esta representação tripla usando arrays associativos em vez de objetos PHP. Assim, o mesmo que vale para N3.js, agora é um array. Por exemplo:
<?php
$ triple = [
' subject ' => ' http://example.org/cartoons#Tom ' ,
' predicate ' => ' http://www.w3.org/1999/02/22-rdf-syntax-ns#type ' ,
' object ' => ' http://example.org/cartoons#Cat ' ,
' graph ' => ' http://example.org/mycartoon ' , #optional
];Codifique literais da seguinte maneira (semelhante a N3.js)
' "Tom"@en-gb ' // lowercase language
'" 1 "^^http: //www.w3.org/2001/XMLSchema#integer' // no angular brackets <> Instale esta biblioteca usando o compositor:
composer require pietercolpaert/ hardf use pietercolpaert hardf TriGWriter ;Uma classe que deve ser instanciada e pode escrever TriG ou Turtle
Exemplo de uso:
$ writer = new TriGWriter ([
" prefixes " => [
" schema " => " http://schema.org/ " ,
" dct " => " http://purl.org/dc/terms/ " ,
" geo " => " http://www.w3.org/2003/01/geo/wgs84_pos# " ,
" rdf " => " http://www.w3.org/1999/02/22-rdf-syntax-ns# " ,
" rdfs " => " http://www.w3.org/2000/01/rdf-schema# "
],
" format " => " n-quads " //Other possible values: n-quads, trig or turtle
]);
$ writer -> addPrefix ( " ex " , " http://example.org/ " );
$ writer -> addTriple ( " schema:Person " , " dct:title " , "" Person " @en " , " http://example.org/#test " );
$ writer -> addTriple ( " schema:Person " , " schema:label " , "" Person " @en " , " http://example.org/#test " );
$ writer -> addTriple ( " ex:1 " , " dct:title " , "" Person1 " @en " , " http://example.org/#test " );
$ writer -> addTriple ( " ex:1 " , " http://www.w3.org/1999/02/22-rdf-syntax-ns#type " , " schema:Person " , " http://example.org/#test " );
$ writer -> addTriple ( " ex:2 " , " dct:title " , "" Person2 " @en " , " http://example.org/#test " );
$ writer -> addTriple ( " schema:Person " , " dct:title " , "" Person " @en " , " http://example.org/#test2 " );
echo $ writer -> end (); //The method names should speak for themselves:
$ writer = new TriGWriter ([ " prefixes " : [ /* ... */ ]]);
$ writer -> addTriple ( $ subject , $ predicate , $ object , $ graphl );
$ writer -> addTriples ( $ triples );
$ writer -> addPrefix ( $ prefix , $ iri );
$ writer -> addPrefixes ( $ prefixes );
//Creates blank node($predicate and/or $object are optional)
$ writer -> blank ( $ predicate , $ object );
//Creates rdf:list with $elements
$ list = $ writer -> addList ( $ elements );
//Returns the current output it is already able to create and clear the internal memory use (useful for streaming)
$ out .= $ writer -> read ();
//Alternatively, you can listen for new chunks through a callback:
$ writer -> setReadCallback ( function ( $ output ) { echo $ output });
//Call this at the end. The return value will be the full triple output, or the rest of the output such as closing dots and brackets, unless a callback was set.
$ out .= $ writer -> end ();
//OR
$ writer -> end ();Ao lado do TriG, a classe TriGParser também analisa Turtle, N-Triples, N-Quads e o W3C Team Submission N3
$ parser = new TriGParser ( $ options , $ tripleCallback , $ prefixCallback );
$ parser -> setTripleCallback ( $ function );
$ parser -> setPrefixCallback ( $ function );
$ parser -> parse ( $ input , $ tripleCallback , $ prefixCallback );
$ parser -> parseChunk ( $ input );
$ parser -> end ();Usando valores de retorno e passando-os para um gravador:
use pietercolpaert hardf TriGParser ;
use pietercolpaert hardf TriGWriter ;
$ parser = new TriGParser ([ " format " => " n-quads " ]); //also parser n-triples, n3, turtle and trig. Format is optional
$ writer = new TriGWriter ();
$ triples = $ parser -> parse ( " <A> <B> <C> <G> . " );
$ writer -> addTriples ( $ triples );
echo $ writer -> end ();Usando retornos de chamada e passando-os para um gravador:
$ parser = new TriGParser ();
$ writer = new TriGWriter ([ " format " => " trig " ]);
$ parser -> parse ( " <http://A> <https://B> <http://C> <http://G> . <A2> <https://B2> <http://C2> <http://G3> . " , function ( $ e , $ triple ) use ( $ writer ) {
if (! isset ( $ e ) && isset ( $ triple )) {
$ writer -> addTriple ( $ triple );
echo $ writer -> read (); //write out what we have so far
} else if (! isset ( $ triple )) // flags the end of the file
echo $ writer -> end (); //write the end
else
echo " Error occured: " . $ e ;
});Quando precisar analisar um arquivo grande, você precisará analisar apenas pedaços e já processá-los. Você pode fazer isso da seguinte maneira:
$ writer = new TriGWriter ([ " format " => " n-quads " ]);
$ tripleCallback = function ( $ error , $ triple ) use ( $ writer ) {
if ( isset ( $ error ))
throw $ error ;
else if ( isset ( $ triple )) {
$ writer -> write ();
echo $ writer -> read ();
else if ( isset ( $ error )) {
throw $ error ;
} else {
echo $ writer -> end ();
}
};
$ prefixCallback = function ( $ prefix , $ iri ) use (& $ writer ) {
$ writer -> addPrefix ( $ prefix , $ iri );
};
$ parser = new TriGParser ([ " format " => " trig " ], $ tripleCallback , $ prefixCallback );
$ parser -> parseChunk ( $ chunk );
$ parser -> parseChunk ( $ chunk );
$ parser -> parseChunk ( $ chunk );
$ parser -> end (); //Needs to be called format (sem distinção entre maiúsculas e minúsculas)turtle - tartarugatrig - TriGtriple , por exemplo, triple , ntriples , N-Triples - N-Triplosquad , por exemplo, quad , nquads , N-Quads - N-Quadsn3 , por exemplo, n3 - N3blankNodePrefix (o padrão é b0_ ) prefixo forçado em nomes de nós em branco, por exemplo TriGWriter(["blankNodePrefix" => 'foo']) analisará _:bar como _:foobar .documentIRI define o URI base usado para resolver URIs relativos (não aplicável se format indicar n-triplos ou n-quads)lexer permite o uso da própria classe lexer. Um lexer deve fornecer os seguintes métodos públicos:tokenize(string $input, bool $finalize = true): array<array{'subject': string, 'predicate': string, 'object': string, 'graph': string}>tokenizeChunk(string $input): array<array{'subject': string, 'predicate': string, 'object': string, 'graph': string}>end(): array<array{'subject': string, 'predicate': string, 'object': string, 'graph': string}>explicitQuantifiers - [...] Alguns documentos Turtle e N3 podem usar sintaxe IRI relativa à base IRI (veja aqui e aqui), por exemplo
<> <someProperty> "some value" .
Para analisar adequadamente esses documentos, o IRI base do documento deve ser conhecido. Caso contrário, poderemos acabar com IRIs vazios (por exemplo, para o assunto do exemplo acima).
Às vezes, o IRI base é codificado no documento, por exemplo
@base <http://some.base/iri/> .
<> <someProperty> "some value" .
mas às vezes falta. Nesse caso a especificação Turtle exige que sigamos a secção 5.1.1 do RFC3986 que diz que se o IRI base não estiver encapsulado no documento, deverá ser assumido como sendo o URI de recuperação do documento (por exemplo, o URL onde descarregou o documento de ou um caminho de arquivo convertido em um URL). Infelizmente isso não pode ser adivinhado pelo analisador hardf e deve ser fornecido por você usando a opção de criação do analisador documentIRI , por exemplo
parser = new TriGParser ([ " documentIRI " => " http://some.base/iri/ " ]); Resumindo a história, se você encontrar o subject/predicate/object on line X can not be parsed without knowing the the document base IRI.(...) , inicialize o analisador com a opção documentIRI .
use pietercolpaert hardf Util ;Uma classe estática com algumas funções úteis para lidar com nossa representação tripla específica. Isso o ajudará a criar e avaliar literais, IRIs e expandir prefixos.
$ bool = isIRI ( $ term );
$ bool = isLiteral ( $ term );
$ bool = isBlank ( $ term );
$ bool = isDefaultGraph ( $ term );
$ bool = inDefaultGraph ( $ triple );
$ value = getLiteralValue ( $ literal );
$ literalType = getLiteralType ( $ literal );
$ lang = getLiteralLanguage ( $ literal );
$ bool = isPrefixedName ( $ term );
$ expanded = expandPrefixedName ( $ prefixedName , $ prefixes );
$ iri = createIRI ( $ iri );
$ literalObject = createLiteral ( $ value , $ modifier = null );Consulte a documentação em https://github.com/RubenVerborgh/N3.js#utility para obter mais informações.
Também oferecemos 2 ferramentas simples em bin/ como exemplo de implementação: um validador e um tradutor. Experimente, por exemplo:
curl -H " accept: application/trig " http://fragments.dbpedia.org/2015/en | php bin/validator.php trig
curl -H " accept: application/trig " http://fragments.dbpedia.org/2015/en | php bin/convert.php trig n-triplesComparamos o desempenho em dois arquivos tartaruga e o analisamos com a biblioteca EasyRDF em PHP, a biblioteca N3.js para NodeJS e com hardf . Estes foram os resultados:
| #triplos | estrutura | tempo (ms) | memória (MB) |
|---|---|---|---|
| 1.866 | hardf sem opcache | 27,6 | 0,722 |
| 1.866 | hardf com opcache | 24,5 | 0,380 |
| 1.866 | EasyRDF sem opcache | 5.166,5 | 2.772 |
| 1.866 | EasyRDF com opcache | 5.176,2 | 2.421 |
| 1.866 | ARC2 com opcache | 71,9 | 1.966 |
| 1.866 | N3.js | 24,0 | 28.xxx |
| 3.896.560 | hardf sem opcache | 40.017,7 | 0,722 |
| 3.896.560 | hardf com opcache | 33.155,3 | 0,380 |
| 3.896.560 | N3.js | 7.004,0 | 59.xxx |
| 3.896.560 | ARC2 com opcache | 203.152,6 | 3.570.808 |
A biblioteca hardf é protegida por direitos autorais de Ruben Verborgh e Pieter Colpaert e lançada sob a licença MIT.
Contribuições são bem-vindas e relatórios de bugs ou solicitações pull são sempre úteis. Se você planeja implementar um recurso maior, é melhor discutir isso primeiro registrando um problema.
