diff options
| author | Joern Hees <dev@joernhees.de> | 2017-01-26 00:29:20 +0100 |
|---|---|---|
| committer | Joern Hees <dev@joernhees.de> | 2017-01-26 00:29:20 +0100 |
| commit | 4204d6b4e0e0cd9a5e1be6460eeef296bc5161df (patch) | |
| tree | 03bc5f4da7737812135fa02e1c239dc36eeb95e2 | |
| parent | cd31f46468cccc518ec3680f21af1967823917bb (diff) | |
| parent | e3690e70a3be4631cbed3dacd1ba0741c1f1c606 (diff) | |
| download | rdflib-4204d6b4e0e0cd9a5e1be6460eeef296bc5161df.tar.gz | |
Merge branch 'master' into 5.0.0-dev
* master: (44 commits)
quote cleanup OCD
serializer/parser alias for 'ntriples'
serializer/parser alias for 'ttl'
cleanup
remove outdated always skipped test
a bit of changelog
add a NTSerializer sub-class for nt11 (#700)
Restrict normalization to unicode-compatible values (#674)
fixes for turtle/trig namespace handling
skip serialising empty default graph
skip round-trip test, unfixable until 5.0
prefix test for #428
Added additional trig unit tests to highlight some currently occurring issues.
remove ancient and broken 2.3 support code. (#681)
updating deprecated testing syntax (#697)
docs: clarify the use of an identifier when persisting a triplestore (#654)
removing pyparsing version requirement (#696)
made min/max aggregate functions support all literals (#694)
actually fix projection from sub-queries
added dawg tests for #607
...
79 files changed, 1468 insertions, 1008 deletions
diff --git a/.hgignore b/.hgignore deleted file mode 100644 index 5e8a4598..00000000 --- a/.hgignore +++ /dev/null @@ -1,14 +0,0 @@ -syntax: glob -build -dist -*.pyc -*~ -*.class -docs/_build -.tox -.coverage -coverage -nosetests.xml -*.egg-info -docs/draft -.pylint diff --git a/CHANGELOG.md b/CHANGELOG.md index 9cada131..3e7fd112 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,44 @@ +2017/01/2X RELEASE 4.2.2 +======================== + +This is a bug-fix release, and the last release in the 4.X series. + +Bug fixes: +---------- +* Many SPARQL Engine fixes for aggregates, subqueries, variable-scope + [#404](https://github.com/RDFLib/rdflib/issues/404) + [#580](https://github.com/RDFLib/rdflib/issues/580) + [#607](https://github.com/RDFLib/rdflib/issues/607) + [#615](https://github.com/RDFLib/rdflib/issues/615) + [#619](https://github.com/RDFLib/rdflib/issues/619) + [#628](https://github.com/RDFLib/rdflib/issues/628) + [#631](https://github.com/RDFLib/rdflib/issues/631) + + +* initBindings in SPARQL queries finally work everywhere + [#294](https://github.com/RDFLib/rdflib/issues/294) + +* A handful of Trig serialisation issues + + [#433](https://github.com/RDFLib/rdflib/issues/433) + [#679](https://github.com/RDFLib/rdflib/issues/679) + [#428](https://github.com/RDFLib/rdflib/issues/428) + + +* Improved support for base64 encoded literals + [#646](https://github.com/RDFLib/rdflib/issues/646) + +* A handful of bugs around orderability on py3 + [#676](https://github.com/RDFLib/rdflib/issues/676) + [#613](https://github.com/RDFLib/rdflib/issues/613) + [#648](https://github.com/RDFLib/rdflib/issues/648) + [#653](https://github.com/RDFLib/rdflib/issues/653) + +* Improved performance of managing large collections + [#609](https://github.com/RDFLib/rdflib/issues/609) + +* And many other minor things! + 2015/08/12 RELEASE 4.2.1 ======================== diff --git a/benchmarks/analysis.ipynb b/benchmarks/analysis.ipynb deleted file mode 100644 index a4bb35f0..00000000 --- a/benchmarks/analysis.ipynb +++ /dev/null @@ -1,423 +0,0 @@ -{ - "metadata": { - "name": "", - "signature": "sha256:6b5be8cb54a05d7e652dc9db2bff975728d7d17455e01ee0f78c858be7ae136b" - }, - "nbformat": 3, - "nbformat_minor": 0, - "worksheets": [ - { - "cells": [ - { - "cell_type": "code", - "collapsed": false, - "input": [ - "import pandas as pd\n", - "import math\n", - "from numpy import nan\n", - "import re\n", - "import plfit\n", - "from matplotlib.ticker import NullFormatter \n", - "\n", - "from pylab import scatter\n", - "import pylab\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib\n", - "import pandas as pd\n", - "import numpy as np\n", - "from scipy import stats \n", - "\n", - "font = {'family' : 'Helvetica',\n", - " 'size' : 16}\n", - "\n", - "matplotlib.rc('font', **font)\n", - "\n", - "data = pd.read_csv(\"/Users/jmccusker/src/rdflib/bioportal_benchmark-11_30-5.csv\")" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 125 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "data['error'] = data['error'].apply(lambda x: \n", - " re.sub(\".+?apikey=([0-9a-z]+[-]?)+\",\"\",x) \n", - " if isinstance(x,str) else x)\n", - "failures = data[data['error'].apply(type) == str]\n", - "successes = data[data['error'].apply(type) != str]\n", - "\n", - "def get_log_bins(values, bin_count):\n", - " bins = [math.log10(min(values)),math.log10(max(values))]\n", - " bins = map(lambda x: (bins[1]-bins[0])*x/float(bin_count)+bins[0], range(bin_count))\n", - " bins = map(lambda x: 10**x, bins) \n", - " return bins\n", - "\n", - "def plot_power_law(x, y, xlabel, ylabel, color=\"blue\", **kwargs):\n", - " fig = plt.figure(1, figsize=(16, 16), dpi=150 )\n", - " nullfmt = NullFormatter() # no labels\n", - " \n", - " left, width = 0.1, 0.9\n", - " bottom, height = 0.1, 0.9\n", - " bottom_h = left_h = left+width+0.02\n", - "\n", - " rect_scatter = [left, bottom, width, height]\n", - " rect_histx = [left, bottom_h, width, 0.1]\n", - " rect_histy = [left_h, bottom, 0.1, height]\n", - "\n", - " ax = plt.axes(rect_scatter)\n", - " ax.scatter(x ,y , c=color, s=64, alpha=0.75)\n", - " ax.set_yscale('log')\n", - " ax.set_xlabel(xlabel)\n", - " ax.set_xscale('log')\n", - " ax.set_ylabel(ylabel)\n", - " xx = x.apply(math.log10)\n", - " yy = y.apply(math.log10)\n", - " \n", - " slope, intercept, r_value, p_value, slope_std_error = stats.linregress(xx, yy)\n", - " \n", - " a = 10**intercept\n", - " b = slope\n", - " predict_y = intercept + slope * xx\n", - " pred_error = yy - predict_y\n", - " degrees_of_freedom = len(xx) - 2\n", - " residual_std_error = np.sqrt(np.sum(pred_error**2) / degrees_of_freedom)\n", - "\n", - " pylab.plot(x, 10**predict_y, 'k-', label=\"Best fit\")\n", - " \n", - " \n", - " axHistx = plt.axes(rect_histx)\n", - " axHisty = plt.axes(rect_histy)\n", - "\n", - " axHistx.set_xscale('log')\n", - " axHistx.set_xlim( ax.get_xlim() ) \n", - " axHistx.xaxis.set_major_formatter(nullfmt)\n", - " axHistx.hist(list(x), get_log_bins(x, 30), facecolor='green', alpha=0.75)\n", - "\n", - " axHisty.set_yscale('log')\n", - " axHisty.set_ylim( ax.get_ylim() ) \n", - " axHisty.yaxis.set_major_formatter(nullfmt)\n", - " axHisty.hist(list(y), get_log_bins(y, 30), facecolor='green', alpha=0.75, orientation='horizontal' )\n", - "\n", - " #print get_log_bins(y, 50)\n", - " \n", - " pylab.show()\n", - " print \"r =\", r_value\n", - " print \"p =\", p_value\n", - " print 10**intercept, slope\n", - " print \"y = %.6f * x^%-.6f\"%(a,b)" - ], - "language": "python", - "metadata": {}, - "outputs": [], - "prompt_number": 126 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "by_triples = data[data['triple_count'] > 0].sort(columns=['triple_count'])\n", - "\n", - "color = by_triples.apply(lambda x: \"red\" if x['color_count'] == 0 \n", - " else (\"yellow\" if x['tree_depth'] > 0 \n", - " else 'blue'), axis=1)\n", - "\n", - "plot_power_law(by_triples['triple_count'], by_triples['to_hash_runtime'], color=color,\n", - " xlabel=\"Size of graph (triples)\", ylabel=\"Execution Time (s)\")\n" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAABOkAAATZCAYAAACB20DfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text": [ - "<matplotlib.figure.Figure at 0x10c964910>" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "r = 0.87394243381\n", - "p = 5.97203048236e-10\n", - "0.000838833513286 1.19394800526\n", - "y = 0.000839 * x^1.193948\n" - ] - } - ], - "prompt_number": 127 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "has_bnodes = data[data['color_count'] > 0]\n", - "has_bnodes = has_bnodes.sort(columns=[\"color_count\"])\n", - "\n", - "color = has_bnodes.apply(lambda x: \"yellow\" if x['tree_depth'] > 0 else 'blue', axis=1)\n", - "plot_power_law(has_bnodes['color_count'], has_bnodes['to_hash_runtime'], color=color,\n", - " xlabel = \"Final color count (nodes)\", ylabel=\"Execution Time (s)\")" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAABOkAAATZCAYAAACB20DfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text": [ - "<matplotlib.figure.Figure at 0x10bf26a10>" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "r = 0.674609167544\n", - "p = 0.00153360598333\n", - "0.166571599173 0.83292265446\n", - "y = 0.166572 * x^0.832923\n" - ] - } - ], - "prompt_number": 122 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "has_bnodes = data[data['color_count'] > 0]\n", - "has_bnodes = has_bnodes.sort(columns=[\"color_count\"])\n", - "\n", - "color = has_bnodes.apply(lambda x: \"yellow\" if x['tree_depth'] > 0 else 'blue', axis=1)\n", - "plot_power_law(has_bnodes['adjacent_nodes'], has_bnodes['to_hash_runtime'], color=color,\n", - " xlabel = \"BNode-adjacent nodes\", ylabel=\"Execution Time (s)\")" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAABOkAAATZCAYAAACB20DfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nB9x3JsSVAAAAAElFTkSuQmCC\n", - "text": [ - "<matplotlib.figure.Figure at 0x10b206890>" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "r = 0.67456664636\n", - "p = 0.00153505792493\n", - "0.298193254262 0.850298736251\n", - "y = 0.298193 * x^0.850299\n" - ] - } - ], - "prompt_number": 123 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "has_bnodes = data[data['color_count'] > 0]\n", - "has_bnodes = has_bnodes.sort(columns=[\"color_count\"])\n", - "\n", - "color = has_bnodes.apply(lambda x: \"yellow\" if x['tree_depth'] > 0 else 'blue', axis=1)\n", - "plot_power_law(has_bnodes['initial_color_count'], has_bnodes['initial_coloring_runtime'], color=color,\n", - " xlabel = \"# Initial Colors\", ylabel=\"Initial Coloring Time (s)\")" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAABOkAAATZCAYAAACB20DfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nABPP/wcH0sf4lpgsjAAAAABJRU5ErkJggg==\n", - "text": [ - "<matplotlib.figure.Figure at 0x10cb0d410>" - ] - }, - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "r = 0.901874307773\n", - "p = 1.32823402317e-07\n", - "0.000438061678081 1.63882831478\n", - "y = 0.000438 * x^1.638828\n" - ] - } - ], - "prompt_number": 128 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "import matplotlib.mlab as mlab\n", - "\n", - "\n", - "x = list(by_triples['triple_count'])\n", - "\n", - "fig = plt.figure()\n", - "ax = fig.add_subplot(111)\n", - "bins = [math.log10(min(x)),math.log10(max(x))]\n", - "print bins\n", - "bins = map(lambda x: (bins[1]-bins[0])*x/50.0+bins[0], range(50))\n", - "print bins\n", - "bins = map(lambda x: 10**x, bins)\n", - "print bins\n", - "\n", - "ax.set_xscale('log')\n", - "# the histogram of the data\n", - "n, bins, patches = ax.hist(x, bins, facecolor='green', alpha=0.75)\n", - "\n", - "# hist uses np.histogram under the hood to create 'n' and 'bins'.\n", - "# np.histogram returns the bin edges, so there will be 50 probability\n", - "# density values in n, 51 bin edges in bins and 50 patches. To get\n", - "# everything lined up, we'll compute the bin centers\n", - "bincenters = 0.5*(bins[1:]+bins[:-1])\n", - "# add a 'best fit' line for the normal PDF\n", - "\n", - "ax.set_xlabel('Triples')\n", - "ax.set_ylabel('Probability')\n", - "#ax.set_title(r'$\\mathrm{Histogram\\ of\\ IQ:}\\ \\mu=100,\\ \\sigma=15$')\n", - "#ax.set_xlim(40, 160)\n", - "#ax.set_ylim(0, 0.03)\n", - "ax.grid(True)\n", - "\n", - "plt.show()" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "stream": "stdout", - "text": [ - "[0.6989700043360189, 5.681665372101854]\n", - "[0.6989700043360189, 0.7986239116913356, 0.8982778190466523, 0.9979317264019689, 1.0975856337572858, 1.1972395411126024, 1.296893448467919, 1.3965473558232357, 1.4962012631785524, 1.595855170533869, 1.695509077889186, 1.7951629852445028, 1.8948168925998194, 1.994470799955136, 2.0941247073104527, 2.1937786146657694, 2.293432522021086, 2.393086429376403, 2.4927403367317194, 2.592394244087036, 2.692048151442353, 2.7917020587976697, 2.8913559661529864, 2.9910098735083026, 3.0906637808636197, 3.1903176882189364, 3.2899715955742534, 3.3896255029295697, 3.4892794102848863, 3.5889333176402034, 3.6885872249955196, 3.7882411323508363, 3.8878950397061534, 3.98754894706147, 4.0872028544167875, 4.186856761772104, 4.28651066912742, 4.386164576482737, 4.485818483838053, 4.58547239119337, 4.6851262985486875, 4.784780205904004, 4.884434113259321, 4.984088020614637, 5.083741927969954, 5.18339583532527, 5.2830497426805865, 5.382703650035904, 5.482357557391221, 5.582011464746538]\n", - "[5.000000000000001, 6.2896128200016195, 7.911845885105742, 9.952489461767623, 12.519461061932933, 15.748512558928887, 19.81040929731912, 24.91996085717951, 31.34738105625095, 39.43257795297436, 49.603129563748155, 62.39689592327036, 78.49046330546157, 98.73492485077952, 124.20088982467183, 156.23510177937285, 196.5316598171602, 247.22160942444174, 310.98564080347995, 391.1958546467971, 492.0940925035974, 619.0162625715375, 778.6745241718859, 979.5122539680295, 1232.150565981201, 1549.949999193522, 1949.7170770578164, 2452.5931046477817, 3085.1722066480515, 3880.9077325692565, 4881.881405602196, 6141.028774880617, 7724.938662097597, 9717.374648571038, 12223.704833282247, 15376.474125465535, 19342.413757190214, 24331.25870739987, 30606.839338567606, 38501.03381671697, 48431.31917538781, 60922.84919502181, 76636.22666560694, 96402.43874251014, 121266.80291886261, 152544.2476558174, 191888.85113470594, 241381.31562244592, 303639.0034495588, 381954.3537497724]\n" - ] - }, - { - "metadata": {}, - "output_type": "display_data", - "png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAEhCAYAAAC3AD1YAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", - "text": [ - "<matplotlib.figure.Figure at 0x10de65350>" - ] - } - ], - "prompt_number": 82 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "has_bnodes['initial_color_count']" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "pyout", - "prompt_number": 32, - "text": [ - "112 2\n", - "95 6\n", - "175 5\n", - "274 10\n", - "308 12\n", - "96 12\n", - "221 13\n", - "204 16\n", - "91 16\n", - "311 25\n", - "325 25\n", - "113 27\n", - "41 31\n", - "316 33\n", - "153 33\n", - "...\n", - "198 2788\n", - "288 2816\n", - "148 2969\n", - "179 3935\n", - "181 4048\n", - "192 4311\n", - "259 5161\n", - "201 6048\n", - "218 6105\n", - "257 8127\n", - "245 10525\n", - "196 12166\n", - "317 12402\n", - "331 12955\n", - "279 17972\n", - "Name: initial_color_count, Length: 121, dtype: float64" - ] - } - ], - "prompt_number": 32 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "range" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "pyout", - "prompt_number": 49, - "text": [ - "3.9535664142570068" - ] - } - ], - "prompt_number": 49 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [ - "len(successes)" - ], - "language": "python", - "metadata": {}, - "outputs": [ - { - "metadata": {}, - "output_type": "pyout", - "prompt_number": 83, - "text": [ - "170" - ] - } - ], - "prompt_number": 83 - }, - { - "cell_type": "code", - "collapsed": false, - "input": [], - "language": "python", - "metadata": {}, - "outputs": [] - } - ], - "metadata": {} - } - ] -}
\ No newline at end of file diff --git a/docs/persistence.rst b/docs/persistence.rst index 6ca69829..fbddf38f 100644 --- a/docs/persistence.rst +++ b/docs/persistence.rst @@ -36,11 +36,13 @@ Most cases passing the name of the store to the Graph constructor is enough: graph = Graph(store='Sleepycat') -Most store offering on-disk persistence will need to be opened before reading or writing : +Most store offering on-disk persistence will need to be opened before reading or writing. +When peristing a triplestore (instead of a ConjuntiveGraph quadstore), you need to specify +an identifier with which you can open the graph: .. code-block:: python - graph = Graph('Sleepycat') + graph = Graph('Sleepycat', identifier='mygraph') # first time create the store: graph.open('/home/user/data/myRDFLibStore', create = True) @@ -49,7 +51,7 @@ Most store offering on-disk persistence will need to be opened before reading or graph.add( mytriples ) # when done! - graph.close() + graph.close() diff --git a/rdflib/collection.py b/rdflib/collection.py index 14351f95..babd4724 100644 --- a/rdflib/collection.py +++ b/rdflib/collection.py @@ -1,7 +1,6 @@ from rdflib.namespace import RDF from rdflib.term import BNode from rdflib.term import Literal -from rdflib.graph import Graph from rdflib.py3compat import format_doctest_out __all__ = ['Collection'] @@ -43,8 +42,7 @@ class Collection(object): def __init__(self, graph, uri, seq=[]): self.graph = graph self.uri = uri or BNode() - for item in seq: - self.append(item) + self += seq def n3(self): """ @@ -82,15 +80,7 @@ class Collection(object): def __len__(self): """length of items in collection.""" - count = 0 - links = set() - for item in self.graph.items(self.uri): - assert item not in links, \ - "There is a loop in the RDF list! " + \ - "(%s has been processed before)" % item - links.add(item) - count += 1 - return count + return len(list(self.graph.items(self.uri))) def index(self, item): """ @@ -192,6 +182,16 @@ class Collection(object): """Iterator over items in Collections""" return self.graph.items(self.uri) + def _end(self): + # find end of list + container = self.uri + while True: + rest = self.graph.value(container, RDF.rest) + if rest == None or rest == RDF.nil: + return container + else: + container = rest + def append(self, item): """ >>> from rdflib.graph import Graph @@ -200,29 +200,36 @@ class Collection(object): >>> c = Collection(g,listName,[Literal(1),Literal(2)]) >>> links = [ ... list(g.subjects(object=i, predicate=RDF.first))[0] for i in c] - >>> len([i for i in links if (i,RDF.rest, RDF.nil) in g]) + >>> len([i for i in links if (i, RDF.rest, RDF.nil) in g]) 1 """ - container = self.uri - graph = self.graph - # iterate to the end of the linked list - rest = graph.value(container, RDF.rest) - while rest: - if rest == RDF.nil: - # the end, append to the end of the linked list - node = BNode() - graph.set((container, RDF.rest, node)) - container = node - break - else: - # move down one link - if container != self.uri: - rest = graph.value(rest, RDF.rest) - if not rest == RDF.nil: - container = rest - graph.add((container, RDF.first, item)) - graph.add((container, RDF.rest, RDF.nil)) + + end = self._end() + if (end, RDF.first, None) in self.graph: + # append new node to the end of the linked list + node = BNode() + self.graph.set((end, RDF.rest, node)) + end = node + + self.graph.add((end, RDF.first, item)) + self.graph.add((end, RDF.rest, RDF.nil)) + + def __iadd__(self, other): + + end = self._end() + self.graph.remove((end, RDF.rest, None)) + + for item in other: + if (end, RDF.first, None) in self.graph: + nxt = BNode() + self.graph.add((end, RDF.rest, nxt)) + end = nxt + + self.graph.add((end, RDF.first, item)) + + + self.graph.add((end, RDF.rest, RDF.nil)) def clear(self): container = self.uri @@ -241,6 +248,7 @@ def test(): if __name__ == "__main__": test() + from rdflib import Graph g = Graph() c = Collection(g, BNode()) diff --git a/rdflib/compat.py b/rdflib/compat.py index 6c714894..bb085dd0 100644 --- a/rdflib/compat.py +++ b/rdflib/compat.py @@ -23,3 +23,60 @@ else: def numeric_greater(a, b): return a > b + + +try: + from lxml import etree +except ImportError: + try: + # Python 2.5 + import xml.etree.cElementTree as etree + except ImportError: + try: + # Python 2.5 + import xml.etree.ElementTree as etree + except ImportError: + try: + # normal cElementTree install + import cElementTree as etree + except ImportError: + try: + # normal ElementTree install + import elementtree.ElementTree as etree + except ImportError: + raise Exception("Failed to import ElementTree from any known place") + +try: + etree_register_namespace = etree.register_namespace +except AttributeError: + + import xml.etree.ElementTree as etreenative + + def etree_register_namespace(prefix, uri): + etreenative._namespace_map[uri] = prefix + +try: + from functools import cmp_to_key +except ImportError: + # Backport from Py2.7 for Py2.6: + def cmp_to_key(mycmp): + """Convert a cmp= function into a key= function""" + class K(object): + __slots__ = ['obj'] + def __init__(self, obj, *args): + self.obj = obj + def __lt__(self, other): + return mycmp(self.obj, other.obj) < 0 + def __gt__(self, other): + return mycmp(self.obj, other.obj) > 0 + def __eq__(self, other): + return mycmp(self.obj, other.obj) == 0 + def __le__(self, other): + return mycmp(self.obj, other.obj) <= 0 + def __ge__(self, other): + return mycmp(self.obj, other.obj) >= 0 + def __ne__(self, other): + return mycmp(self.obj, other.obj) != 0 + def __hash__(self): + raise TypeError('hash not implemented') + return K diff --git a/rdflib/graph.py b/rdflib/graph.py index dd12d7ae..8f962a6f 100644 --- a/rdflib/graph.py +++ b/rdflib/graph.py @@ -266,6 +266,7 @@ from rdflib.parser import Parser from rdflib.parser import create_input_source from rdflib.namespace import NamespaceManager from rdflib.resource import Resource +from rdflib.collection import Collection from rdflib import py3compat b = py3compat.b @@ -1172,6 +1173,28 @@ class Graph(Node): res.update(self.subjects()) return res + def collection(self, identifier): + """Create a new ``Collection`` instance. + + Parameters: + + - ``identifier``: a URIRef or BNode instance. + + Example:: + + >>> graph = Graph() + >>> uri = URIRef("http://example.org/resource") + >>> collection = graph.collection(uri) + >>> assert isinstance(collection, Collection) + >>> assert collection.uri is uri + >>> assert collection.graph is graph + >>> collection += [ Literal(1), Literal(2) ] + """ + + return Collection(self, identifier) + + + def resource(self, identifier): """Create a new ``Resource`` instance. diff --git a/rdflib/plugin.py b/rdflib/plugin.py index b5d2efeb..f810e648 100644 --- a/rdflib/plugin.py +++ b/rdflib/plugin.py @@ -167,15 +167,25 @@ register( 'turtle', Serializer, 'rdflib.plugins.serializers.turtle', 'TurtleSerializer') register( + 'ttl', Serializer, + 'rdflib.plugins.serializers.turtle', 'TurtleSerializer') +register( 'trig', Serializer, 'rdflib.plugins.serializers.trig', 'TrigSerializer') register( 'application/n-triples', Serializer, 'rdflib.plugins.serializers.nt', 'NTSerializer') register( + 'ntriples', Serializer, + 'rdflib.plugins.serializers.nt', 'NTSerializer') +register( 'nt', Serializer, 'rdflib.plugins.serializers.nt', 'NTSerializer') register( + 'nt11', Serializer, + 'rdflib.plugins.serializers.nt', 'NT11Serializer') + +register( 'pretty-xml', Serializer, 'rdflib.plugins.serializers.rdfxml', 'PrettyXMLSerializer') register( @@ -185,10 +195,10 @@ register( 'application/trix', Serializer, 'rdflib.plugins.serializers.trix', 'TriXSerializer') register( - "application/n-quads", Serializer, + 'application/n-quads', Serializer, 'rdflib.plugins.serializers.nquads', 'NQuadsSerializer') register( - "nquads", Serializer, + 'nquads', Serializer, 'rdflib.plugins.serializers.nquads', 'NQuadsSerializer') register( @@ -210,12 +220,21 @@ register( 'turtle', Parser, 'rdflib.plugins.parsers.notation3', 'TurtleParser') register( + 'ttl', Parser, + 'rdflib.plugins.parsers.notation3', 'TurtleParser') +register( 'application/n-triples', Parser, 'rdflib.plugins.parsers.nt', 'NTParser') register( + 'ntriples', Parser, + 'rdflib.plugins.parsers.nt', 'NTParser') +register( 'nt', Parser, 'rdflib.plugins.parsers.nt', 'NTParser') register( + 'nt11', Parser, + 'rdflib.plugins.parsers.nt', 'NTParser') +register( 'application/n-quads', Parser, 'rdflib.plugins.parsers.nquads', 'NQuadsParser') register( diff --git a/rdflib/plugins/serializers/nquads.py b/rdflib/plugins/serializers/nquads.py index 26cd85ef..66c5e6f1 100644 --- a/rdflib/plugins/serializers/nquads.py +++ b/rdflib/plugins/serializers/nquads.py @@ -4,7 +4,7 @@ from rdflib.term import Literal from rdflib.serializer import Serializer from rdflib.py3compat import b -from rdflib.plugins.serializers.nt import _xmlcharref_encode, _quoteLiteral +from rdflib.plugins.serializers.nt import _quoteLiteral __all__ = ['NQuadsSerializer'] @@ -36,11 +36,10 @@ def _nq_row(triple, context): if isinstance(triple[2], Literal): return u"%s %s %s %s .\n" % (triple[0].n3(), triple[1].n3(), - _xmlcharref_encode( - _quoteLiteral(triple[2])), + _quoteLiteral(triple[2]), context.n3()) else: return u"%s %s %s %s .\n" % (triple[0].n3(), triple[1].n3(), - _xmlcharref_encode(triple[2].n3()), + triple[2].n3(), context.n3()) diff --git a/rdflib/plugins/serializers/nt.py b/rdflib/plugins/serializers/nt.py index 6b3c6485..ca9eadf5 100644 --- a/rdflib/plugins/serializers/nt.py +++ b/rdflib/plugins/serializers/nt.py @@ -6,7 +6,9 @@ format. from rdflib.term import Literal from rdflib.serializer import Serializer from rdflib.py3compat import b + import warnings +import codecs __all__ = ['NTSerializer'] @@ -16,6 +18,10 @@ class NTSerializer(Serializer): Serializes RDF graphs to NTriples format. """ + def __init__(self, store): + Serializer.__init__(self, store) + self.encoding = 'ascii' # n-triples are ascii encoded + def serialize(self, stream, base=None, encoding=None, **args): if base is not None: warnings.warn("NTSerializer does not support base.") @@ -23,20 +29,31 @@ class NTSerializer(Serializer): warnings.warn("NTSerializer does not use custom encoding.") encoding = self.encoding for triple in self.store: - stream.write(_nt_row(triple).encode(encoding, "replace")) + stream.write(_nt_row(triple).encode(self.encoding, "_rdflib_nt_escape")) stream.write(b("\n")) +class NT11Serializer(NTSerializer): + """ + Serializes RDF graphs to RDF 1.1 NTriples format. + + Exactly like nt - only utf8 encoded. + """ + + def __init__(self, store): + Serializer.__init__(self, store) # default to utf-8 + + def _nt_row(triple): if isinstance(triple[2], Literal): return u"%s %s %s .\n" % ( triple[0].n3(), triple[1].n3(), - _xmlcharref_encode(_quoteLiteral(triple[2]))) + _quoteLiteral(triple[2])) else: return u"%s %s %s .\n" % (triple[0].n3(), triple[1].n3(), - _xmlcharref_encode(triple[2].n3())) + triple[2].n3()) def _quoteLiteral(l): @@ -62,23 +79,18 @@ def _quote_encode(l): .replace('"', '\\"')\ .replace('\r', '\\r') +def _nt_unicode_error_resolver(err): + + """ + Do unicode char replaces as defined in https://www.w3.org/TR/2004/REC-rdf-testcases-20040210/#ntrip_strings + """ + + def _replace_single(c): + c = ord(c) + fmt = u'\\u%04X' if c <= 0xFFFF else u'\\U%08X' + return fmt % c + + string = err.object[err.start:err.end] + return ( "".join( _replace_single(c) for c in string ), err.end ) -# from <http://code.activestate.com/recipes/303668/> -def _xmlcharref_encode(unicode_data, encoding="ascii"): - """Emulate Python 2.3's 'xmlcharrefreplace' encoding error handler.""" - res = "" - - # Step through the unicode_data string one character at a time in - # order to catch unencodable characters: - for char in unicode_data: - try: - char.encode(encoding, 'strict') - except UnicodeError: - if ord(char) <= 0xFFFF: - res += '\\u%04X' % ord(char) - else: - res += '\\U%08X' % ord(char) - else: - res += char - - return res +codecs.register_error('_rdflib_nt_escape', _nt_unicode_error_resolver) diff --git a/rdflib/plugins/serializers/trig.py b/rdflib/plugins/serializers/trig.py index f8bd789d..5036050c 100644 --- a/rdflib/plugins/serializers/trig.py +++ b/rdflib/plugins/serializers/trig.py @@ -60,6 +60,8 @@ class TrigSerializer(TurtleSerializer): firstTime = True for store, (ordered_subjects, subjects, ref) in self._contexts.items(): + if not ordered_subjects: continue + self._references = ref self._serialized = {} self.store = store diff --git a/rdflib/plugins/serializers/turtle.py b/rdflib/plugins/serializers/turtle.py index addfa481..9027ed3d 100644 --- a/rdflib/plugins/serializers/turtle.py +++ b/rdflib/plugins/serializers/turtle.py @@ -5,6 +5,7 @@ See <http://www.w3.org/TeamSubmission/turtle/> for syntax specification. from collections import defaultdict +from rdflib.compat import cmp_to_key from rdflib.term import BNode, Literal, URIRef from rdflib.exceptions import Error from rdflib.serializer import Serializer @@ -12,6 +13,25 @@ from rdflib.namespace import RDF, RDFS __all__ = ['RecursiveSerializer', 'TurtleSerializer'] +def _object_comparator(a,b): + """ + for nice clean output we sort the objects of triples, + some of them are literals, + these are sorted according to the sort order of the underlying python objects + in py3 not all things are comparable. + This falls back on comparing string representations when not. + """ + + try: + if a>b: return 1 + if a<b: return -1 + return 0 + + except TypeError: + a = unicode(a) + b = unicode(b) + return (a > b) - (a < b) + class RecursiveSerializer(Serializer): @@ -27,6 +47,8 @@ class RecursiveSerializer(Serializer): self.reset() def addNamespace(self, prefix, uri): + if prefix in self.namespaces and self.namespaces[prefix]!=uri: + raise Exception("Trying to override namespace prefix %s => %s, but it's already bound to %s"%(prefix, uri, self.namespaces[prefix])) self.namespaces[prefix] = uri def checkSubject(self, subject): @@ -103,7 +125,7 @@ class RecursiveSerializer(Serializer): Sort the lists of values. Return a sorted list of properties.""" # Sort object lists for prop, objects in properties.items(): - objects.sort() + objects.sort(key=cmp_to_key(_object_comparator)) # Make sorted list of properties propList = [] @@ -175,7 +197,8 @@ class TurtleSerializer(RecursiveSerializer): p = "p" + p self._ns_rewrite[prefix] = p - prefix = self._ns_rewrite.get(prefix, prefix) + prefix = self._ns_rewrite.get(prefix, prefix) + super(TurtleSerializer, self).addNamespace(prefix, namespace) return prefix diff --git a/rdflib/plugins/sparql/aggregates.py b/rdflib/plugins/sparql/aggregates.py index 1ca9e3b8..7ffe1de4 100644 --- a/rdflib/plugins/sparql/aggregates.py +++ b/rdflib/plugins/sparql/aggregates.py @@ -1,10 +1,10 @@ from rdflib import Literal, XSD -from rdflib.plugins.sparql.evalutils import _eval, NotBoundError +from rdflib.plugins.sparql.evalutils import _eval, NotBoundError, _val from rdflib.plugins.sparql.operators import numeric from rdflib.plugins.sparql.datatypes import type_promotion -from rdflib.plugins.sparql.compat import num_max, num_min +from rdflib.plugins.sparql.sparql import SPARQLTypeError from decimal import Decimal @@ -12,157 +12,249 @@ from decimal import Decimal Aggregation functions """ +class Accumulator(object): + """abstract base class for different aggregation functions """ -def _eval_rows(expr, group, distinct): - seen = set() - for row in group: - try: - val = _eval(expr, row) - if not distinct or not val in seen: - yield val - seen.add(val) - except: - pass + def __init__(self, aggregation): + self.var = aggregation.res + self.expr = aggregation.vars + if not aggregation.distinct: + self.use_row = self.dont_care + self.distinct = False + else: + self.distinct = aggregation.distinct + self.seen = set() + + def dont_care(self, row): + """skips distinct test """ + return True + + def use_row(self, row): + """tests distinct with set """ + return _eval(self.expr, row) not in self.seen + + def set_value(self, bindings): + """sets final value in bindings""" + bindings[self.var] = self.get_value() -def agg_Sum(a, group, bindings): - c = 0 +class Counter(Accumulator): - dt = None - for e in _eval_rows(a.vars, group, a.distinct): + def __init__(self, aggregation): + super(Counter, self).__init__(aggregation) + self.value = 0 + if self.expr == "*": + # cannot eval "*" => always use the full row + self.eval_row = self.eval_full_row + + def update(self, row, aggregator): try: - n = numeric(e) - if dt == None: - dt = e.datatype - else: - dt = type_promotion(dt, e.datatype) + val = self.eval_row(row) + except NotBoundError: + # skip UNDEF + return + self.value += 1 + if self.distinct: + self.seen.add(val) - if type(c) == float and type(n) == Decimal: - c += float(n) - elif type(n) == float and type(c) == Decimal: - c = float(c) + n - else: - c += n - except: - pass # simply dont count + def get_value(self): + return Literal(self.value) - bindings[a.res] = Literal(c, datatype=dt) + def eval_row(self, row): + return _eval(self.expr, row) -# Perhaps TODO: keep datatype for max/min? + def eval_full_row(self, row): + return row + def use_row(self, row): + return self.eval_row(row) not in self.seen -def agg_Min(a, group, bindings): - m = None - for v in _eval_rows(a.vars, group, None): # DISTINCT makes no difference for MIN +def type_safe_numbers(*args): + types = map(type, args) + if float in types and Decimal in types: + return map(float, args) + return args + + +class Sum(Accumulator): + + def __init__(self, aggregation): + super(Sum, self).__init__(aggregation) + self.value = 0 + self.datatype = None + + def update(self, row, aggregator): try: - v = numeric(v) - if m is None: - m = v + value = _eval(self.expr, row) + dt = self.datatype + if dt is None: + dt = value.datatype else: - m = num_min(v, m) - except: - continue # try other values + dt = type_promotion(dt, value.datatype) + self.datatype = dt + self.value = sum(type_safe_numbers(self.value, numeric(value))) + if self.distinct: + self.seen.add(value) + except NotBoundError: + # skip UNDEF + pass - if m is not None: - bindings[a.res] = Literal(m) + def get_value(self): + return Literal(self.value, datatype=self.datatype) +class Average(Accumulator): -def agg_Max(a, group, bindings): - m = None + def __init__(self, aggregation): + super(Average, self).__init__(aggregation) + self.counter = 0 + self.sum = 0 + self.datatype = None - for v in _eval_rows(a.vars, group, None): # DISTINCT makes no difference for MAX + def update(self, row, aggregator): try: - v = numeric(v) - if m is None: - m = v + value = _eval(self.expr, row) + dt = self.datatype + self.sum = sum(type_safe_numbers(self.sum, numeric(value))) + if dt is None: + dt = value.datatype else: - m = num_max(v, m) - except: - return # error in aggregate => no binding + dt = type_promotion(dt, value.datatype) + self.datatype = dt + if self.distinct: + self.seen.add(value) + self.counter += 1 + # skip UNDEF or BNode => SPARQLTypeError + except NotBoundError: + pass + except SPARQLTypeError: + pass - if m is not None: - bindings[a.res] = Literal(m) + def get_value(self): + if self.counter == 0: + return Literal(0) + if self.datatype in (XSD.float, XSD.double): + return Literal(self.sum / self.counter) + else: + return Literal(Decimal(self.sum) / Decimal(self.counter)) -def agg_Count(a, group, bindings): - if a.vars == '*': - c = len(group) - else: - c = 0 - for e in _eval_rows(a.vars, group, a.distinct): - c += 1 +class Extremum(Accumulator): + """abstract base class for Minimum and Maximum""" - bindings[a.res] = Literal(c) + def __init__(self, aggregation): + super(Extremum, self).__init__(aggregation) + self.value = None + # DISTINCT would not change the value for MIN or MAX + self.use_row = self.dont_care + def set_value(self, bindings): + if self.value is not None: + # simply do not set if self.value is still None + bindings[self.var] = Literal(self.value) -def agg_Sample(a, group, bindings): - for ctx in group: + def update(self, row, aggregator): try: - bindings[a.res] = _eval(a.vars, ctx) - break + if self.value is None: + self.value = _eval(self.expr, row) + else: + # self.compare is implemented by Minimum/Maximum + self.value = self.compare(self.value, _eval(self.expr, row)) + # skip UNDEF or BNode => SPARQLTypeError except NotBoundError: pass + except SPARQLTypeError: + pass + + +class Minimum(Extremum): + def compare(self, val1, val2): + return min(val1, val2, key=_val) -def agg_GroupConcat(a, group, bindings): - sep = a.separator or " " - if a.distinct: - agg = lambda x: x - else: - add = set +class Maximum(Extremum): - bindings[a.res] = Literal( - sep.join(unicode(x) for x in _eval_rows(a.vars, group, a.distinct))) + def compare(self, val1, val2): + return max(val1, val2, key=_val) -def agg_Avg(a, group, bindings): +class Sample(Accumulator): + """takes the first eligable value""" - c = 0 - s = 0 - dt = None - for e in _eval_rows(a.vars, group, a.distinct): + def __init__(self, aggregation): + super(Sample, self).__init__(aggregation) + # DISTINCT would not change the value + self.use_row = self.dont_care + + def update(self, row, aggregator): try: - n = numeric(e) - if dt == None: - dt = e.datatype - else: - dt = type_promotion(dt, e.datatype) + # set the value now + aggregator.bindings[self.var] = _eval(self.expr, row) + # and skip this accumulator for future rows + del aggregator.accumulators[self.var] + except NotBoundError: + pass - if type(s) == float and type(n) == Decimal: - s += float(n) - elif type(n) == float and type(s) == Decimal: - s = float(s) + n - else: - s += n - c += 1 - except: - return # error in aggregate => no binding - - if c == 0: - bindings[a.res] = Literal(0) - if dt == XSD.float or dt == XSD.double: - bindings[a.res] = Literal(s / c) - else: - bindings[a.res] = Literal(Decimal(s) / Decimal(c)) - - -def evalAgg(a, group, bindings): - if a.name == 'Aggregate_Count': - return agg_Count(a, group, bindings) - elif a.name == 'Aggregate_Sum': - return agg_Sum(a, group, bindings) - elif a.name == 'Aggregate_Sample': - return agg_Sample(a, group, bindings) - elif a.name == 'Aggregate_GroupConcat': - return agg_GroupConcat(a, group, bindings) - elif a.name == 'Aggregate_Avg': - return agg_Avg(a, group, bindings) - elif a.name == 'Aggregate_Min': - return agg_Min(a, group, bindings) - elif a.name == 'Aggregate_Max': - return agg_Max(a, group, bindings) - - else: - raise Exception("Unknown aggregate function " + a.name) + def get_value(self): + # set None if no value was set + return None + +class GroupConcat(Accumulator): + + def __init__(self, aggregation): + super(GroupConcat, self).__init__(aggregation) + # only GROUPCONCAT needs to have a list as accumlator + self.value = [] + self.separator = aggregation.separator or " " + + def update(self, row, aggregator): + try: + value = _eval(self.expr, row) + self.value.append(value) + if self.distinct: + self.seen.add(value) + # skip UNDEF + except NotBoundError: + pass + + def get_value(self): + return Literal(self.separator.join(unicode(v) for v in self.value)) + + +class Aggregator(object): + """combines different Accumulator objects""" + + accumulator_classes = { + "Aggregate_Count": Counter, + "Aggregate_Sample": Sample, + "Aggregate_Sum": Sum, + "Aggregate_Avg": Average, + "Aggregate_Min": Minimum, + "Aggregate_Max": Maximum, + "Aggregate_GroupConcat": GroupConcat, + } + + def __init__(self, aggregations): + self.bindings = {} + self.accumulators = {} + for a in aggregations: + accumulator_class = self.accumulator_classes.get(a.name) + if accumulator_class is None: + raise Exception("Unknown aggregate function " + a.name) + self.accumulators[a.res] = accumulator_class(a) + + def update(self, row): + """update all own accumulators""" + # SAMPLE accumulators may delete themselves + # => iterate over list not generator + + for acc in self.accumulators.values(): + if acc.use_row(row): + acc.update(row, self) + + def get_bindings(self): + """calculate and set last values""" + for acc in self.accumulators.itervalues(): + acc.set_value(self.bindings) + return self.bindings diff --git a/rdflib/plugins/sparql/algebra.py b/rdflib/plugins/sparql/algebra.py index 099594a3..60b2a692 100644 --- a/rdflib/plugins/sparql/algebra.py +++ b/rdflib/plugins/sparql/algebra.py @@ -203,6 +203,9 @@ def translateExists(e): if isinstance(n, CompValue): if n.name in ('Builtin_EXISTS', 'Builtin_NOTEXISTS'): n.graph = translateGroupGraphPattern(n.graph) + if n.graph.name == 'Filter': + # filters inside (NOT) EXISTS can see vars bound outside + n.graph.no_isolated_scope = True e = traverse(e, visitPost=_c) @@ -428,20 +431,31 @@ def _findVars(x, res): def _addVars(x, children): - # import pdb; pdb.set_trace() + """ + find which variables may be bound by this part of the query + """ if isinstance(x, Variable): return set([x]) elif isinstance(x, CompValue): - x["_vars"] = set(reduce(operator.or_, children, set())) - if x.name == "Bind": - return set([x.var]) - elif x.name == 'SubSelect': - if x.projection: - s = set(v.var or v.evar for v in x.projection) - else: - s = set() + if x.name == "RelationalExpression": + x["_vars"] = set() + elif x.name == "Extend": + # vars only used in the expr for a bind should not be included + x["_vars"] = reduce(operator.or_, [ child for child,part in zip(children,x) if part!='expr' ], set()) + + else: + x["_vars"] = set(reduce(operator.or_, children, set())) + + if x.name == 'SubSelect': + if x.projection: + s = set(v.var or v.evar for v in x.projection) + else: + s = set() + + return s + + return x["_vars"] - return s return reduce(operator.or_, children, set()) @@ -629,6 +643,12 @@ def simplify(n): def analyse(n, children): + """ + Some things can be lazily joined. + This propegates whether they can up the tree + and sets lazy flags for all joins + """ + if isinstance(n, CompValue): if n.name == 'Join': n["lazy"] = all(children) diff --git a/rdflib/plugins/sparql/compat.py b/rdflib/plugins/sparql/compat.py index 01147b70..bb8e250a 100644 --- a/rdflib/plugins/sparql/compat.py +++ b/rdflib/plugins/sparql/compat.py @@ -23,29 +23,3 @@ try: from collections import OrderedDict # was added in 2.7 except ImportError: from ordereddict import OrderedDict # extra module - -import sys - -if sys.version_info[:2] < (2, 7): - - from decimal import Decimal - # Pre-2.7 decimal and float did not compare correctly - - def _numericKey(n): - if isinstance(n, Decimal): - return float(n) - else: - return n - - def num_max(*args, **kwargs): - kwargs["key"] = _numericKey - return max(*args, **kwargs) - - def num_min(*args, **kwargs): - kwargs["key"] = _numericKey - return min(*args, **kwargs) - -else: - - num_max = max - num_min = min diff --git a/rdflib/plugins/sparql/evaluate.py b/rdflib/plugins/sparql/evaluate.py index e558a825..6b59f532 100644 --- a/rdflib/plugins/sparql/evaluate.py +++ b/rdflib/plugins/sparql/evaluate.py @@ -23,9 +23,9 @@ from rdflib.plugins.sparql.parserutils import value from rdflib.plugins.sparql.sparql import ( QueryContext, AlreadyBound, FrozenBindings, SPARQLError) from rdflib.plugins.sparql.evalutils import ( - _filter, _eval, _join, _diff, _minus, _fillTemplate, _ebv) + _filter, _eval, _join, _diff, _minus, _fillTemplate, _ebv, _val) -from rdflib.plugins.sparql.aggregates import evalAgg +from rdflib.plugins.sparql.aggregates import Aggregator from rdflib.plugins.sparql.algebra import Join, ToMultiSet, Values def evalBGP(ctx, bgp): @@ -74,7 +74,7 @@ def evalExtend(ctx, extend): for c in evalPart(ctx, extend.p): try: - e = _eval(extend.expr, c.forget(ctx)) + e = _eval(extend.expr, c.forget(ctx, _except=extend._vars)) if isinstance(e, SPARQLError): raise e @@ -94,7 +94,7 @@ def evalLazyJoin(ctx, join): for a in evalPart(ctx, join.p1): c = ctx.thaw(a) for b in evalPart(c, join.p2): - yield b + yield b.merge(a) # merge, as some bindings may have been forgotten def evalJoin(ctx, join): @@ -141,8 +141,10 @@ def evalLeftJoin(ctx, join): # before we yield a solution without the OPTIONAL part # check that we would have had no OPTIONAL matches # even without prior bindings... - if not any(_ebv(join.expr, b) for b in - evalPart(ctx.thaw(a.remember(join.p1._vars)), join.p2)): + p1_vars = join.p1._vars + if p1_vars is None \ + or not any(_ebv(join.expr, b) for b in + evalPart(ctx.thaw(a.remember(p1_vars)), join.p2)): yield a @@ -150,7 +152,7 @@ def evalLeftJoin(ctx, join): def evalFilter(ctx, part): # TODO: Deal with dict returned from evalPart! for c in evalPart(ctx, part.p): - if _ebv(part.expr, c.forget(ctx)): + if _ebv(part.expr, c.forget(ctx, _except=part._vars) if not part.no_isolated_scope else c): yield c @@ -275,16 +277,8 @@ def evalGroup(ctx, group): """ http://www.w3.org/TR/sparql11-query/#defn_algGroup """ - - p = evalPart(ctx, group.p) - if not group.expr: - return {1: list(p)} - else: - res = collections.defaultdict(list) - for c in p: - k = tuple(_eval(e, c, False) for e in group.expr) - res[k].append(c) - return res + # grouping should be implemented by evalAggregateJoin + return evalPart(ctx, group.p) def evalAggregateJoin(ctx, agg): @@ -292,16 +286,28 @@ def evalAggregateJoin(ctx, agg): p = evalPart(ctx, agg.p) # p is always a Group, we always get a dict back - for row in p: - bindings = {} - for a in agg.A: - evalAgg(a, p[row], bindings) + group_expr = agg.p.expr + res = collections.defaultdict(lambda: Aggregator(aggregations=agg.A)) - yield FrozenBindings(ctx, bindings) + if group_expr is None: + # no grouping, just COUNT in SELECT clause + # get 1 aggregator for counting + aggregator = res[True] + for row in p: + aggregator.update(row) + else: + for row in p: + # determine right group aggregator for row + k = tuple(_eval(e, row, False) for e in group_expr) + res[k].update(row) - if len(p) == 0: - yield FrozenBindings(ctx) + # all rows are done; yield aggregated values + for aggregator in res.itervalues(): + yield FrozenBindings(ctx, aggregator.get_bindings()) + # there were no matches + if len(res) == 0: + yield FrozenBindings(ctx) def evalOrderBy(ctx, part): @@ -310,19 +316,8 @@ def evalOrderBy(ctx, part): for e in reversed(part.expr): - def val(x): - v = value(x, e.expr, variables=True) - if isinstance(v, Variable): - return (0, v) - elif isinstance(v, BNode): - return (1, v) - elif isinstance(v, URIRef): - return (2, v) - elif isinstance(v, Literal): - return (3, v) - reverse = bool(e.order and e.order == 'DESC') - res = sorted(res, key=val, reverse=reverse) + res = sorted(res, key=lambda x: _val(value(x, e.expr, variables=True)), reverse=reverse) return res @@ -347,7 +342,41 @@ def evalSlice(ctx, slice): def evalReduced(ctx, part): - return evalPart(ctx, part.p) # TODO! + """apply REDUCED to result + + REDUCED is not as strict as DISTINCT, but if the incoming rows were sorted + it should produce the same result with limited extra memory and time per + incoming row. + """ + + # This implementation uses a most recently used strategy and a limited + # buffer size. It relates to a LRU caching algorithm: + # https://en.wikipedia.org/wiki/Cache_algorithms#Least_Recently_Used_.28LRU.29 + MAX = 1 + # TODO: add configuration or determine "best" size for most use cases + # 0: No reduction + # 1: compare only with the last row, almost no reduction with + # unordered incoming rows + # N: The greater the buffer size the greater the reduction but more + # memory and time are needed + + # mixed data structure: set for lookup, deque for append/pop/remove + mru_set = set() + mru_queue = collections.deque() + + for row in evalPart(ctx, part.p): + if row in mru_set: + # forget last position of row + mru_queue.remove(row) + else: + #row seems to be new + yield row + mru_set.add(row) + if len(mru_set) > MAX: + # drop the least recently used row from buffer + mru_set.remove(mru_queue.pop()) + # put row to the front + mru_queue.appendleft(row) def evalDistinct(ctx, part): @@ -406,41 +435,13 @@ def evalConstructQuery(ctx, query): def evalQuery(graph, query, initBindings, base=None): - ctx = QueryContext(graph) - ctx.prologue = query.prologue + initBindings = dict( ( Variable(k),v ) for k,v in initBindings.iteritems() ) - main = query.algebra + ctx = QueryContext(graph, initBindings=initBindings) - if initBindings: - # add initBindings as a values clause - - values = {} # no dict comprehension in 2.6 :( - for k,v in initBindings.iteritems(): - if not isinstance(k, Variable): - k = Variable(k) - values[k] = v - - main = main.clone() # clone to not change prepared q - main['p'] = main.p.clone() - # Find the right place to insert MultiSet join - repl = main.p - if repl.name == 'Slice': - repl['p'] = repl.p.clone() - repl = repl.p - if repl.name == 'Distinct': - repl['p'] = repl.p.clone() - repl = repl.p - if repl.p.name == 'OrderBy': - repl['p'] = repl.p.clone() - repl = repl.p - if repl.p.name == 'Extend': - repl['p'] = repl.p.clone() - repl = repl.p - - repl['p'] = Join(repl.p, ToMultiSet(Values([values]))) - - # TODO: Vars? + ctx.prologue = query.prologue + main = query.algebra if main.datasetClause: if ctx.dataset is None: diff --git a/rdflib/plugins/sparql/evalutils.py b/rdflib/plugins/sparql/evalutils.py index ddfe2311..dd0924d0 100644 --- a/rdflib/plugins/sparql/evalutils.py +++ b/rdflib/plugins/sparql/evalutils.py @@ -3,7 +3,7 @@ import collections from rdflib.term import Variable, Literal, BNode, URIRef from rdflib.plugins.sparql.operators import EBV -from rdflib.plugins.sparql.parserutils import Expr, CompValue +from rdflib.plugins.sparql.parserutils import Expr, CompValue, value from rdflib.plugins.sparql.sparql import SPARQLError, NotBoundError @@ -112,3 +112,14 @@ def _fillTemplate(template, solution): _o is not None: yield (_s, _p, _o) + +def _val(v): + """ utilitity for ordering things""" + if isinstance(v, Variable): + return (0, v) + elif isinstance(v, BNode): + return (1, v) + elif isinstance(v, URIRef): + return (2, v) + elif isinstance(v, Literal): + return (3, v) diff --git a/rdflib/plugins/sparql/parserutils.py b/rdflib/plugins/sparql/parserutils.py index b5c25600..7e4a3665 100644 --- a/rdflib/plugins/sparql/parserutils.py +++ b/rdflib/plugins/sparql/parserutils.py @@ -241,6 +241,31 @@ class Comp(TokenConverter): return self +def prettify_parsetree(t, indent='', depth=0): + out = [] + if isinstance(t, ParseResults): + for e in t.asList(): + out.append(prettify_parsetree(e, indent, depth + 1)) + for k, v in sorted(t.items()): + out.append("%s%s- %s:\n" % (indent, ' ' * depth, k)) + out.append(prettify_parsetree(v, indent, depth + 1)) + elif isinstance(t, CompValue): + out.append("%s%s> %s:\n" % (indent, ' ' * depth, t.name)) + for k, v in t.items(): + out.append("%s%s- %s:\n" % (indent, ' ' * (depth + 1), k)) + out.append(prettify_parsetree(v, indent, depth + 2)) + elif isinstance(t, dict): + for k, v in t.items(): + out.append("%s%s- %s:\n" % (indent, ' ' * (depth + 1), k)) + out.append(prettify_parsetree(v, indent, depth + 2)) + elif isinstance(t, list): + for e in t: + out.append(prettify_parsetree(e, indent, depth + 1)) + else: + out.append("%s%s- %r\n" % (indent, ' ' * depth, t)) + return "".join(out) + + if __name__ == '__main__': from pyparsing import Word, nums import sys diff --git a/rdflib/plugins/sparql/results/xmlresults.py b/rdflib/plugins/sparql/results/xmlresults.py index 8c7f0000..b31f9513 100644 --- a/rdflib/plugins/sparql/results/xmlresults.py +++ b/rdflib/plugins/sparql/results/xmlresults.py @@ -3,7 +3,7 @@ from xml.sax.saxutils import XMLGenerator from xml.dom import XML_NAMESPACE from xml.sax.xmlreader import AttributesNSImpl -from xml.etree import cElementTree as ElementTree +from rdflib.compat import etree from rdflib import Literal, URIRef, BNode, Graph, Variable from rdflib.query import ( @@ -42,7 +42,7 @@ class XMLResult(Result): if isinstance(xmlstring, unicode): xmlstring = xmlstring.encode('utf-8') try: - tree = ElementTree.fromstring(xmlstring) + tree = etree.fromstring(xmlstring) except Exception, e: try: raise e.__class__("error parsing %r: %s" % (xmlstring, e)) @@ -145,7 +145,7 @@ class SPARQLXMLWriter: def __init__(self, output, encoding='utf-8'): writer = XMLGenerator(output, encoding) writer.startDocument() - writer.startPrefixMapping(u'sparql', SPARQL_XML_NAMESPACE) + writer.startPrefixMapping(u'', SPARQL_XML_NAMESPACE) writer.startPrefixMapping(u'xml', XML_NAMESPACE) writer.startElementNS( (SPARQL_XML_NAMESPACE, u'sparql'), diff --git a/rdflib/plugins/sparql/sparql.py b/rdflib/plugins/sparql/sparql.py index 76eded8f..c012a8fc 100644 --- a/rdflib/plugins/sparql/sparql.py +++ b/rdflib/plugins/sparql/sparql.py @@ -191,13 +191,14 @@ class FrozenBindings(FrozenDict): bnodes = property(_bnodes) now = property(_now) - def forget(self, before): + def forget(self, before, _except=None): """ return a frozen dict only of bindings made in self since before """ - - return FrozenBindings(self.ctx, (x for x in self.iteritems() if before[x[0]] is None)) + if not _except : _except = [] + # bindings from initBindings are newer forgotten + return FrozenBindings(self.ctx, (x for x in self.iteritems() if x[0] in _except or x[0] in self.ctx.initBindings or before[x[0]] is None)) def remember(self, these): """ @@ -212,8 +213,10 @@ class QueryContext(object): Query context - passed along when evaluating the query """ - def __init__(self, graph=None, bindings=None): - self.bindings = bindings or Bindings() + def __init__(self, graph=None, bindings=None, initBindings=None): + self.initBindings = initBindings + self.bindings = Bindings(d=bindings or []) + if initBindings: self.bindings.update(initBindings) if isinstance(graph, ConjunctiveGraph): self._dataset = graph @@ -232,9 +235,8 @@ class QueryContext(object): def clone(self, bindings=None): r = QueryContext( - self._dataset if self._dataset is not None else self.graph) + self._dataset if self._dataset is not None else self.graph, bindings or self.bindings, initBindings=self.initBindings) r.prologue = self.prologue - r.bindings.update(bindings or self.bindings) r.graph = self.graph r.bnodes = self.bnodes return r diff --git a/rdflib/plugins/sparql/update.py b/rdflib/plugins/sparql/update.py index 57c5bf46..f5a5f2eb 100644 --- a/rdflib/plugins/sparql/update.py +++ b/rdflib/plugins/sparql/update.py @@ -252,7 +252,7 @@ def evalCopy(ctx, u): dstg += srcg -def evalUpdate(graph, update, initBindings=None): +def evalUpdate(graph, update, initBindings={}): """ http://www.w3.org/TR/sparql11-update/#updateLanguage @@ -274,15 +274,11 @@ def evalUpdate(graph, update, initBindings=None): for u in update: - ctx = QueryContext(graph) + initBindings = dict( ( Variable(k),v ) for k,v in initBindings.iteritems() ) + + ctx = QueryContext(graph, initBindings=initBindings) ctx.prologue = u.prologue - if initBindings: - for k, v in initBindings.iteritems(): - if not isinstance(k, Variable): - k = Variable(k) - ctx[k] = v - # ctx.push() # nescessary? try: if u.name == 'Load': diff --git a/rdflib/plugins/stores/sparqlstore.py b/rdflib/plugins/stores/sparqlstore.py index 16b9564b..3feb4a55 100644 --- a/rdflib/plugins/stores/sparqlstore.py +++ b/rdflib/plugins/stores/sparqlstore.py @@ -13,7 +13,8 @@ ORDERBY = 'ORDER BY' import re import collections -import urllib2 +import warnings +import contextlib try: from SPARQLWrapper import SPARQLWrapper, XML, POST, GET, URLENCODED, POSTDIRECTLY @@ -22,20 +23,7 @@ except ImportError: "SPARQLWrapper not found! SPARQL Store will not work." + "Install with 'easy_install SPARQLWrapper'") -import sys -if getattr(sys, 'pypy_version_info', None) is not None \ - or sys.platform.startswith('java') \ - or sys.version_info[:2] < (2, 6): - # import elementtree as etree - from elementtree import ElementTree - assert ElementTree -else: - try: - from xml.etree import ElementTree - assert ElementTree - except ImportError: - from elementtree import ElementTree - +from rdflib.compat import etree, etree_register_namespace from rdflib.plugins.stores.regexmatching import NATIVE_REGEX from rdflib.store import Store @@ -44,9 +32,6 @@ from rdflib import Variable, Namespace, BNode, URIRef, Literal from rdflib.graph import DATASET_DEFAULT_GRAPH_ID from rdflib.term import Node -import httplib -import urlparse - class NSSPARQLWrapper(SPARQLWrapper): nsBindings = {} @@ -88,7 +73,7 @@ class NSSPARQLWrapper(SPARQLWrapper): BNODE_IDENT_PATTERN = re.compile('(?P<label>_\:[^\s]+)') SPARQL_NS = Namespace('http://www.w3.org/2005/sparql-results#') sparqlNsBindings = {u'sparql': SPARQL_NS} -ElementTree._namespace_map["sparql"] = SPARQL_NS +etree_register_namespace("sparql", SPARQL_NS) def _node_from_result(node): @@ -205,6 +190,7 @@ class SPARQLStore(NSSPARQLWrapper, Store): sparql11=True, context_aware=True, node_to_sparql=_node_to_sparql, node_from_result=_node_from_result, + default_query_method=GET, **sparqlwrapper_kwargs): """ """ @@ -218,6 +204,7 @@ class SPARQLStore(NSSPARQLWrapper, Store): self.context_aware = context_aware self.graph_aware = context_aware self._timeout = None + self.query_method = default_query_method # Database Management Methods def create(self, configuration): @@ -281,12 +268,15 @@ class SPARQLStore(NSSPARQLWrapper, Store): " ".join(self.node_to_sparql(initBindings[x]) for x in v)) self.resetQuery() + self.setMethod(self.query_method) if self._is_contextual(queryGraph): self.addParameter("default-graph-uri", queryGraph) self.timeout = self._timeout self.setQuery(query) - return Result.parse(SPARQLWrapper.query(self).response) + with contextlib.closing(SPARQLWrapper.query(self).response) as res: + return Result.parse(res) + def triples(self, (s, p, o), context=None): """ @@ -374,7 +364,9 @@ class SPARQLStore(NSSPARQLWrapper, Store): self.timeout = self._timeout self.setQuery(query) - doc = ElementTree.parse(SPARQLWrapper.query(self).response) + with contextlib.closing(SPARQLWrapper.query(self).response) as res: + doc = etree.parse(res) + # ElementTree.dump(doc) for rt, vars in _traverse_sparql_result_dom( doc, @@ -405,7 +397,10 @@ class SPARQLStore(NSSPARQLWrapper, Store): if self._is_contextual(context): self.addParameter("default-graph-uri", context.identifier) self.setQuery(q) - doc = ElementTree.parse(SPARQLWrapper.query(self).response) + + with contextlib.closing(SPARQLWrapper.query(self).response) as res: + doc = etree.parse(res) + rt, vars = iter( _traverse_sparql_result_dom( doc, @@ -441,7 +436,8 @@ class SPARQLStore(NSSPARQLWrapper, Store): else: self.setQuery('SELECT ?name WHERE { GRAPH ?name {} }') - doc = ElementTree.parse(SPARQLWrapper.query(self).response) + with contextlib.closing(SPARQLWrapper.query(self).response) as res: + doc = etree.parse(res) return ( rt.get(Variable("name")) @@ -725,7 +721,8 @@ class SPARQLUpdateStore(SPARQLStore): # we must read (and discard) the whole response # otherwise the network socket buffer will at some point be "full" # and we will block - result.response.read() + with contextlib.closing(result.response) as res: + res.read() def update(self, query, initNs={}, diff --git a/rdflib/term.py b/rdflib/term.py index fa7973ff..2bdad22a 100644 --- a/rdflib/term.py +++ b/rdflib/term.py @@ -50,7 +50,6 @@ from collections import defaultdict from isodate import parse_time, parse_date, parse_datetime - try: from hashlib import md5 assert md5 @@ -63,7 +62,6 @@ from . import py3compat from rdflib.compat import numeric_greater - b = py3compat.b skolem_genid = "/.well-known/genid/" @@ -83,6 +81,24 @@ _lang_tag_regex = compile('^[a-zA-Z]+(?:-[a-zA-Z0-9]+)*$') def _is_valid_langtag(tag): return bool(_lang_tag_regex.match(tag)) +def _is_valid_unicode(value): + """ + Verify that the provided value can be converted into a Python + unicode object. + """ + if isinstance(value, bytes): + coding_func, param = getattr(value, 'decode'), 'utf-8' + elif py3compat.PY3: + coding_func, param = str, value + else: + coding_func, param = unicode, value + + # try to convert value into unicode + try: + coding_func(param) + except UnicodeError: + return False + return True class Node(object): """ @@ -543,7 +559,7 @@ class Literal(Identifier): if value is not None and normalize: _value, _datatype = _castPythonToLiteral(value) - if _value is not None: + if _value is not None and _is_valid_unicode(_value): lexical_or_value = _value else: @@ -557,7 +573,6 @@ class Literal(Identifier): if datatype: lang = None - if py3compat.PY3 and isinstance(lexical_or_value, bytes): lexical_or_value = lexical_or_value.decode('utf-8') @@ -1452,8 +1467,7 @@ XSDToPython = { URIRef(_XSD_PFX + 'unsignedByte'): int, URIRef(_XSD_PFX + 'float'): float, URIRef(_XSD_PFX + 'double'): float, - URIRef( - _XSD_PFX + 'base64Binary'): lambda s: base64.b64decode(py3compat.b(s)), + URIRef(_XSD_PFX + 'base64Binary'): lambda s: base64.b64decode(s), URIRef(_XSD_PFX + 'anyURI'): None, _RDF_XMLLITERAL: _parseXML, _RDF_HTMLLITERAL: _parseHTML diff --git a/requirements.py2.txt b/requirements.py2.txt index 4f8f97cf..4851bb36 100644 --- a/requirements.py2.txt +++ b/requirements.py2.txt @@ -1,5 +1,5 @@ flake8 html5lib isodate -pyparsing<=1.5.7 +pyparsing SPARQLWrapper @@ -42,7 +42,8 @@ if sys.version_info[0] >= 3: kwargs['tests_require'] = ['html5lib', 'networkx'] kwargs['requires'] = [ 'isodate', 'pyparsing', - 'SPARQLWrapper'] + ] + html5lib = 'html5lib' kwargs['src_root'] = setup_python3() assert setup else: @@ -52,7 +53,7 @@ else: kwargs['test_suite'] = "nose.collector" kwargs['install_requires'] = [ 'isodate', - 'pyparsing', 'SPARQLWrapper'] + 'pyparsing'] kwargs['tests_require'] = ['networkx'] if sys.version_info[1]<7: # Python 2.6 @@ -60,14 +61,18 @@ else: if sys.version_info[1]<6: # Python 2.5 kwargs['install_requires'].append('pyparsing<=1.5.7') kwargs['install_requires'].append('simplejson') - kwargs['install_requires'].append('html5lib==0.95') + html5lib = 'html5lib==0.95' else: - kwargs['install_requires'].append('html5lib') + html5lib = 'html5lib' except ImportError: from distutils.core import setup, find_packages + html5lib = None - +if html5lib is not None: # ie. we're not using the simplified distutils setup + kwargs['extras_require'] = {'sparql': ['SPARQLWrapper'], 'html': [html5lib]} + kwargs['tests_require'].append('SPARQLWrapper') + kwargs['tests_require'].append(html5lib) # Find version. We have to do this because we can't import it in Python 3 until diff --git a/test/DAWG/rdflib/bindscope.rq b/test/DAWG/rdflib/bindscope.rq new file mode 100644 index 00000000..35ae3904 --- /dev/null +++ b/test/DAWG/rdflib/bindscope.rq @@ -0,0 +1,6 @@ +PREFIX s: <http://schema.org/> + +SELECT ?s ?o ?x WHERE { + ?x s:knows ?o . + { ?x a s:Person. BIND(?x as ?s) } +} diff --git a/test/DAWG/rdflib/bindscope.srx b/test/DAWG/rdflib/bindscope.srx new file mode 100644 index 00000000..91cd6c93 --- /dev/null +++ b/test/DAWG/rdflib/bindscope.srx @@ -0,0 +1,22 @@ +<?xml version="1.0"?> +<sparql xmlns="http://www.w3.org/2005/sparql-results#"> + <head> + <variable name="s"/> + <variable name="o"/> + <variable name="x"/> + </head> + <results> + <result> + <binding name="s"> + <uri>http://example.org/jane</uri> + </binding> + <binding name="o"> + <uri>http://example.org/john</uri> + </binding> + <binding name="x"> + <uri>http://example.org/jane</uri> + </binding> + + </result> + </results> +</sparql> diff --git a/test/DAWG/rdflib/bindscope.ttl b/test/DAWG/rdflib/bindscope.ttl new file mode 100644 index 00000000..4f732820 --- /dev/null +++ b/test/DAWG/rdflib/bindscope.ttl @@ -0,0 +1,6 @@ +@prefix s: <http://schema.org/> . +@prefix x: <http://example.org/> . + +x:john a s:Person ; s:name "John" . +x:jane a s:Person ; s:name "Jane" ; s:knows x:john. +x:ecorp a s:Organization ; s:name "Evil Corp" ; s:employee x:jane .
\ No newline at end of file diff --git a/test/DAWG/rdflib/bindscope2.rq b/test/DAWG/rdflib/bindscope2.rq new file mode 100644 index 00000000..1e825d21 --- /dev/null +++ b/test/DAWG/rdflib/bindscope2.rq @@ -0,0 +1,9 @@ +PREFIX s: <http://schema.org/> +PREFIX x: <http://example.org/> + +SELECT ?s ?p ?o ?x +WHERE { + ?x a s:Person . + { ?x ?p ?o . BIND (?x as ?s) } UNION + { ?s ?p ?x . BIND (?x as ?o) } +} diff --git a/test/DAWG/rdflib/bindscope2.tsv b/test/DAWG/rdflib/bindscope2.tsv new file mode 100644 index 00000000..8bed6717 --- /dev/null +++ b/test/DAWG/rdflib/bindscope2.tsv @@ -0,0 +1,8 @@ +?s ?p ?o ?x +<http://example.org/john> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> <http://example.org/john> +<http://example.org/john> <http://schema.org/name> "John" <http://example.org/john> +<http://example.org/jane> <http://schema.org/knows> <http://example.org/john> <http://example.org/john> +<http://example.org/jane> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> <http://example.org/jane> +<http://example.org/jane> <http://schema.org/name> "Jane" <http://example.org/jane> +<http://example.org/jane> <http://schema.org/knows> <http://example.org/john> <http://example.org/jane> +<http://example.org/ecorp> <http://schema.org/employee> <http://example.org/jane> <http://example.org/jane>
\ No newline at end of file diff --git a/test/DAWG/rdflib/filteroptional.rq b/test/DAWG/rdflib/filteroptional.rq new file mode 100644 index 00000000..7f617ad2 --- /dev/null +++ b/test/DAWG/rdflib/filteroptional.rq @@ -0,0 +1,8 @@ +SELECT ?this +WHERE { + VALUES ?this { <http://ex.com/a> "HI" } + OPTIONAL { + VALUES ?this { <http://ex.com/a> "HI" } + FILTER ( isIRI(?this) ) + } +} diff --git a/test/DAWG/rdflib/filtersubquery.tsv b/test/DAWG/rdflib/filtersubquery.tsv new file mode 100644 index 00000000..24d9f2c2 --- /dev/null +++ b/test/DAWG/rdflib/filtersubquery.tsv @@ -0,0 +1,2 @@ +?this +<http://ex.com/a>
\ No newline at end of file diff --git a/test/DAWG/rdflib/filtersubquery1.rq b/test/DAWG/rdflib/filtersubquery1.rq new file mode 100644 index 00000000..6e87d9b7 --- /dev/null +++ b/test/DAWG/rdflib/filtersubquery1.rq @@ -0,0 +1,4 @@ +SELECT ?this WHERE { + VALUES ?this { <http://ex.com/a> "HI" } + FILTER ( isIRI(?this) ) +} diff --git a/test/DAWG/rdflib/filtersubquery2.rq b/test/DAWG/rdflib/filtersubquery2.rq new file mode 100644 index 00000000..aa36e1ca --- /dev/null +++ b/test/DAWG/rdflib/filtersubquery2.rq @@ -0,0 +1,10 @@ +SELECT ?this +WHERE { + { SELECT ?this WHERE { + VALUES ?this { <http://ex.com/a> "HI" } + FILTER ( isIRI(?this) ) + } } + { SELECT ?this WHERE { + VALUES ?this { <http://ex.com/a> "HI" } + } } +} diff --git a/test/DAWG/rdflib/filtersubquery3.rq b/test/DAWG/rdflib/filtersubquery3.rq new file mode 100644 index 00000000..0799d16f --- /dev/null +++ b/test/DAWG/rdflib/filtersubquery3.rq @@ -0,0 +1,10 @@ +SELECT ?this +WHERE { + { SELECT ?this WHERE { + VALUES ?this { <http://ex.com/a> "HI" } + } } + { SELECT ?this WHERE { + VALUES ?this { <http://ex.com/a> "HI" } + FILTER ( isIRI(?this) ) + } } +} diff --git a/test/DAWG/rdflib/manifest.ttl b/test/DAWG/rdflib/manifest.ttl index 63b884ad..85ba2db5 100644 --- a/test/DAWG/rdflib/manifest.ttl +++ b/test/DAWG/rdflib/manifest.ttl @@ -14,6 +14,24 @@ :unicode :nestedbnode :whitespacedot + :minusfilter + :notexistsfilter + + :bindscope + :bindscope2 + + :filtersubquery1 + :filtersubquery2 + :filtersubquery3 + :filteroptional + + :subquery1 + :subquery2 + :subquery3 + + :subqueryagg1 + :subqueryagg2 + ) . @@ -22,7 +40,7 @@ dawgt:approval dawgt:Approved ; dawgt:approvedBy <http://gromgull.net/> ; mf:action - [ qt:query <optsubq.rq> ; + [ qt:query <optsubq.rq> ; qt:data <optsubq.ttl> ] ; mf:result <optsubq.srx> . @@ -32,7 +50,7 @@ dawgt:approval dawgt:Approved ; dawgt:approvedBy <http://gromgull.net/me> ; mf:action - [ qt:query <unicode.rq> ; + [ qt:query <unicode.rq> ; qt:data <unicode.ttl> ] ; mf:result <unicode.srx> . @@ -43,7 +61,7 @@ dawgt:approval dawgt:Approved ; dawgt:approvedBy <http://gromgull.net/me> ; mf:action - [ qt:query <nestedbnode.rq> ] ; + [ qt:query <nestedbnode.rq> ] ; mf:result <nestedbnode.srx> . @@ -53,3 +71,178 @@ dawgt:approvedBy <http://gromgull.net/me> ; mf:action <whitespacedot.rq> . + + + +:minusfilter rdf:type mf:QueryEvaluationTest ; + mf:name "Filter in MINUS"; + rdfs:comment """' with MINUS, the FILTER inside the pattern does not have a value for ?n and it is always unbound:' +From https://github.com/RDFLib/rdflib/issues/615, contributed by https://github.com/pfps""" ; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <minusfilter.rq> ; + qt:data <minusfilter.ttl> ] ; + mf:result <minusfilter.srx> + . + +:notexistsfilter rdf:type mf:QueryEvaluationTest ; + mf:name "Filter in NOT EXISTS"; + rdfs:comment """'the FILTER inside the NOT EXISTS has access to the value of ?n for the solution being considered.' +From https://github.com/RDFLib/rdflib/issues/615, contributed by https://github.com/pfps""" ; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <notexistsfilter.rq> ; + qt:data <minusfilter.ttl> ] ; + mf:result <notexistsfilter.srx> + . + + +:bindscope rdf:type mf:QueryEvaluationTest ; + mf:name "Scope of bind in groups"; + rdfs:comment """ + From https://github.com/RDFLib/rdflib/issues/580, contributed by https://github.com/pchampin +"""; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <bindscope.rq> ; + qt:data <bindscope.ttl> ] ; + mf:result <bindscope.srx> + . + + +:bindscope2 rdf:type mf:QueryEvaluationTest ; + mf:name "Scope of bind in groups2"; + rdfs:comment """ + From https://github.com/RDFLib/rdflib/issues/580, contributed by https://github.com/pchampin +"""; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <bindscope2.rq> ; + qt:data <bindscope.ttl> ] ; + mf:result <bindscope2.tsv> + . + +:filtersubquery1 rdf:type mf:QueryEvaluationTest ; + mf:name "filters in subqueries 1"; + rdfs:comment """ + From https://github.com/RDFLib/rdflib/issues/619, contributed by https://github.com/pfps +"""; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <filtersubquery1.rq> ] ; + mf:result <filtersubquery.tsv> + . + + +:filtersubquery2 rdf:type mf:QueryEvaluationTest ; + mf:name "filters in subqueries 2 - filter in first subquery"; + rdfs:comment """ + From https://github.com/RDFLib/rdflib/issues/619, contributed by https://github.com/pfps +"""; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <filtersubquery2.rq> ] ; + mf:result <filtersubquery.tsv> + . + + +:filtersubquery3 rdf:type mf:QueryEvaluationTest ; + mf:name "filters in subqueries 2 - filter in second subquery"; + rdfs:comment """ + From https://github.com/RDFLib/rdflib/issues/619, contributed by https://github.com/pfps +"""; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <filtersubquery3.rq> ] ; + mf:result <filtersubquery.tsv> + . + + +:filteroptional rdf:type mf:QueryEvaluationTest ; + mf:name "filters in optional"; + rdfs:comment """ + From https://github.com/RDFLib/rdflib/issues/619, contributed by https://github.com/pfps +"""; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <filteroptional.rq> ] ; + mf:result <filtersubquery.tsv> + . + + +:subquery1 rdf:type mf:QueryEvaluationTest ; + mf:name "subquery1"; + rdfs:comment """ + From https://github.com/RDFLib/rdflib/issues/607, contributed by https://github.com/pfps +"""; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <subquery1.rq> ; + qt:data <subquery.ttl> ] ; + mf:result <subquery.tsv> + . + + +:subquery2 rdf:type mf:QueryEvaluationTest ; + mf:name "subquery2"; + rdfs:comment """ + From https://github.com/RDFLib/rdflib/issues/607, contributed by https://github.com/pfps +"""; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <subquery2.rq> ; + qt:data <subquery.ttl> ] ; + mf:result <subquery.tsv> + . + + +:subquery3 rdf:type mf:QueryEvaluationTest ; + mf:name "subquery3"; + rdfs:comment """ + From https://github.com/RDFLib/rdflib/issues/607, contributed by https://github.com/pfps +"""; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <subquery3.rq> ; + qt:data <subquery.ttl> ] ; + mf:result <subquery.tsv> + . + + +:subqueryagg1 rdf:type mf:QueryEvaluationTest ; + mf:name "plain query aggregation function"; + rdfs:comment """ + From https://github.com/RDFLib/rdflib/issues/628, contributed by https://github.com/wrobell +"""; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <subqueryagg1.rq> ; + qt:data <subqueryagg.ttl> ] ; + mf:result <subqueryagg.tsv> + . + + +:subqueryagg2 rdf:type mf:QueryEvaluationTest ; + mf:name "subquery aggregation function"; + rdfs:comment """ + From https://github.com/RDFLib/rdflib/issues/628, contributed by https://github.com/wrobell +"""; + dawgt:approval dawgt:Approved ; + dawgt:approvedBy <http://gromgull.net/me> ; + mf:action + [ qt:query <subqueryagg.rq> ; + qt:data <subqueryagg.ttl> ] ; + mf:result <subqueryagg.tsv> + . diff --git a/test/DAWG/rdflib/minusfilter.rq b/test/DAWG/rdflib/minusfilter.rq new file mode 100644 index 00000000..b381afe6 --- /dev/null +++ b/test/DAWG/rdflib/minusfilter.rq @@ -0,0 +1,8 @@ +PREFIX : <http://example.com/> +SELECT ?x ?n WHERE { + ?x :p ?n + MINUS { + ?x :q ?m . + FILTER(?n = ?m) + } +} diff --git a/test/DAWG/rdflib/minusfilter.srx b/test/DAWG/rdflib/minusfilter.srx new file mode 100644 index 00000000..94baded6 --- /dev/null +++ b/test/DAWG/rdflib/minusfilter.srx @@ -0,0 +1,25 @@ +<?xml version="1.0"?> +<sparql xmlns="http://www.w3.org/2005/sparql-results#"> + <head> + <variable name="x"/> + <variable name="n"/> + </head> + <results> + <result> + <binding name="x"> + <uri>http://example.com/a</uri> + </binding> + <binding name="n"> + <literal datatype="http://www.w3.org/2001/XMLSchema#integer">1</literal> + </binding> + </result> + <result> + <binding name="x"> + <uri>http://example.com/b</uri> + </binding> + <binding name="n"> + <literal datatype="http://www.w3.org/2001/XMLSchema#decimal">3.0</literal> + </binding> + </result> + </results> +</sparql> diff --git a/test/DAWG/rdflib/minusfilter.ttl b/test/DAWG/rdflib/minusfilter.ttl new file mode 100644 index 00000000..a4ec1d64 --- /dev/null +++ b/test/DAWG/rdflib/minusfilter.ttl @@ -0,0 +1,8 @@ +@prefix : <http://example.com/> . +:a :p 1 . +:a :q 1 . +:a :q 2 . + +:b :p 3.0 . +:b :q 4.0 . +:b :q 5.0 .
\ No newline at end of file diff --git a/test/DAWG/rdflib/notexistsfilter.rq b/test/DAWG/rdflib/notexistsfilter.rq new file mode 100644 index 00000000..586be72a --- /dev/null +++ b/test/DAWG/rdflib/notexistsfilter.rq @@ -0,0 +1,8 @@ +PREFIX : <http://example.com/> +SELECT ?x ?n WHERE { + ?x :p ?n + FILTER NOT EXISTS { + ?x :q ?m . + FILTER(?n = ?m) + } +} diff --git a/test/DAWG/rdflib/notexistsfilter.srx b/test/DAWG/rdflib/notexistsfilter.srx new file mode 100644 index 00000000..fede17eb --- /dev/null +++ b/test/DAWG/rdflib/notexistsfilter.srx @@ -0,0 +1,17 @@ +<?xml version="1.0"?> +<sparql xmlns="http://www.w3.org/2005/sparql-results#"> + <head> + <variable name="x"/> + <variable name="n"/> + </head> + <results> + <result> + <binding name="x"> + <uri>http://example.com/b</uri> + </binding> + <binding name="n"> + <literal datatype="http://www.w3.org/2001/XMLSchema#decimal">3.0</literal> + </binding> + </result> + </results> +</sparql> diff --git a/test/DAWG/rdflib/subquery.tsv b/test/DAWG/rdflib/subquery.tsv new file mode 100644 index 00000000..9b33f488 --- /dev/null +++ b/test/DAWG/rdflib/subquery.tsv @@ -0,0 +1,2 @@ +?a ?b ?c +<http://example.org/a> <http://example.org/b> <http://example.org/c>
\ No newline at end of file diff --git a/test/DAWG/rdflib/subquery.ttl b/test/DAWG/rdflib/subquery.ttl new file mode 100644 index 00000000..77c2bdb7 --- /dev/null +++ b/test/DAWG/rdflib/subquery.ttl @@ -0,0 +1,4 @@ +@prefix x: <http://example.org/> . +x:a x:p x:b . +x:b x:p x:c . +x:x x:p x:y .
\ No newline at end of file diff --git a/test/DAWG/rdflib/subquery1.rq b/test/DAWG/rdflib/subquery1.rq new file mode 100644 index 00000000..862c6400 --- /dev/null +++ b/test/DAWG/rdflib/subquery1.rq @@ -0,0 +1,9 @@ +# baseline - actually no subquery +# find 2 hop chain (this works) + +PREFIX x: <http://example.org/> + +SELECT ?a ?b ?c WHERE { + ?a x:p ?b . + ?b x:p ?c . +} diff --git a/test/DAWG/rdflib/subquery2.rq b/test/DAWG/rdflib/subquery2.rq new file mode 100644 index 00000000..66125cdb --- /dev/null +++ b/test/DAWG/rdflib/subquery2.rq @@ -0,0 +1,12 @@ +# find 2 hop chain with subquery + +PREFIX x: <http://example.org/> + +SELECT ?a ?b ?c WHERE { + ?a x:p ?b . + { + SELECT ?b ?c WHERE { + ?b x:p ?c . + } + } +} diff --git a/test/DAWG/rdflib/subquery3.rq b/test/DAWG/rdflib/subquery3.rq new file mode 100644 index 00000000..f2e12618 --- /dev/null +++ b/test/DAWG/rdflib/subquery3.rq @@ -0,0 +1,12 @@ +# find 2 hop chain with subquery, exec subquery first + +PREFIX x: <http://example.org/> + +SELECT ?a ?b ?c WHERE { + { + SELECT ?b ?c WHERE { + ?b x:p ?c . + } + } + ?a x:p ?b . +} diff --git a/test/DAWG/rdflib/subqueryagg.rq b/test/DAWG/rdflib/subqueryagg.rq new file mode 100644 index 00000000..3ee1a3e3 --- /dev/null +++ b/test/DAWG/rdflib/subqueryagg.rq @@ -0,0 +1,12 @@ +PREFIX : <http://people.example/> + +SELECT ?y ?minName +WHERE { + :alice :knows ?y . + { + SELECT ?y (MIN(?name) AS ?minName) + WHERE { + ?y :name ?name . + } GROUP BY ?y + } +} diff --git a/test/DAWG/rdflib/subqueryagg.tsv b/test/DAWG/rdflib/subqueryagg.tsv new file mode 100644 index 00000000..c6460797 --- /dev/null +++ b/test/DAWG/rdflib/subqueryagg.tsv @@ -0,0 +1,3 @@ +?y ?minName +<http://people.example/bob> "B. Bar" +<http://people.example/carol> "C. Baz" diff --git a/test/DAWG/rdflib/subqueryagg.ttl b/test/DAWG/rdflib/subqueryagg.ttl new file mode 100644 index 00000000..20271065 --- /dev/null +++ b/test/DAWG/rdflib/subqueryagg.ttl @@ -0,0 +1,6 @@ +@prefix : <http://people.example/> . + +:alice :name "Alice", "Alice Foo", "A. Foo" . +:alice :knows :bob, :carol . +:bob :name "Bob", "Bob Bar", "B. Bar" . +:carol :name "Carol", "Carol Baz", "C. Baz" . diff --git a/test/DAWG/rdflib/subqueryagg1.rq b/test/DAWG/rdflib/subqueryagg1.rq new file mode 100644 index 00000000..959188d7 --- /dev/null +++ b/test/DAWG/rdflib/subqueryagg1.rq @@ -0,0 +1,7 @@ +PREFIX : <http://people.example/> + +SELECT ?y (MIN(?name) as ?minName) +WHERE { + :alice :knows ?y . + ?y :name ?name . +} GROUP BY ?y diff --git a/test/test_comparison.py b/test/test_comparison.py index d91ae86e..316718f0 100644 --- a/test/test_comparison.py +++ b/test/test_comparison.py @@ -40,31 +40,31 @@ class IdentifierEquality(unittest.TestCase): self.python_literal_2 = u"foo" def testA(self): - self.assertEquals(self.uriref==self.literal, False) + self.assertEqual(self.uriref==self.literal, False) def testB(self): - self.assertEquals(self.literal==self.uriref, False) + self.assertEqual(self.literal==self.uriref, False) def testC(self): - self.assertEquals(self.uriref==self.python_literal, False) + self.assertEqual(self.uriref==self.python_literal, False) def testD(self): - self.assertEquals(self.python_literal==self.uriref, False) + self.assertEqual(self.python_literal==self.uriref, False) def testE(self): - self.assertEquals(self.literal==self.python_literal, False) + self.assertEqual(self.literal==self.python_literal, False) def testE2(self): self.assertTrue(self.literal.eq(self.python_literal), True) def testF(self): - self.assertEquals(self.python_literal==self.literal, False) + self.assertEqual(self.python_literal==self.literal, False) def testG(self): - self.assertEquals("foo" in CORE_SYNTAX_TERMS, False) + self.assertEqual("foo" in CORE_SYNTAX_TERMS, False) def testH(self): - self.assertEquals(URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#RDF") in CORE_SYNTAX_TERMS, True) + self.assertEqual(URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#RDF") in CORE_SYNTAX_TERMS, True) def testI(self): g = Graph() diff --git a/test/test_conventions.py b/test/test_conventions.py index 7dc0b3c5..307b79b9 100644 --- a/test/test_conventions.py +++ b/test/test_conventions.py @@ -33,12 +33,11 @@ class A(unittest.TestCase): else: if name!=name.lower() and name not in skip_as_ignorably_private: names.add(name) - #self.assert_(name==name.lower(), "module name '%s' is not lower case" % name) return names def test_module_names(self): names = self.module_names() - self.assert_(names==set(), "module names '%s' are not lower case" % names) + self.assertTrue(names==set(), "module names '%s' are not lower case" % names) try: getattr(pkgutil, 'iter_modules') diff --git a/test/test_dataset.py b/test/test_dataset.py index 4d39c3d6..47e3b716 100644 --- a/test/test_dataset.py +++ b/test/test_dataset.py @@ -89,37 +89,37 @@ class DatasetTestCase(unittest.TestCase): # empty named graphs if self.store != "SPARQLUpdateStore": # added graph exists - self.assertEquals(set(x.identifier for x in self.graph.contexts()), + self.assertEqual(set(x.identifier for x in self.graph.contexts()), set([self.c1, DATASET_DEFAULT_GRAPH_ID])) # added graph is empty - self.assertEquals(len(g1), 0) + self.assertEqual(len(g1), 0) g1.add( (self.tarek, self.likes, self.pizza) ) # added graph still exists - self.assertEquals(set(x.identifier for x in self.graph.contexts()), + self.assertEqual(set(x.identifier for x in self.graph.contexts()), set([self.c1, DATASET_DEFAULT_GRAPH_ID])) # added graph contains one triple - self.assertEquals(len(g1), 1) + self.assertEqual(len(g1), 1) g1.remove( (self.tarek, self.likes, self.pizza) ) # added graph is empty - self.assertEquals(len(g1), 0) + self.assertEqual(len(g1), 0) # Some SPARQL endpoint backends (e.g. TDB) do not consider # empty named graphs if self.store != "SPARQLUpdateStore": # graph still exists, although empty - self.assertEquals(set(x.identifier for x in self.graph.contexts()), + self.assertEqual(set(x.identifier for x in self.graph.contexts()), set([self.c1, DATASET_DEFAULT_GRAPH_ID])) g.remove_graph(self.c1) # graph is gone - self.assertEquals(set(x.identifier for x in self.graph.contexts()), + self.assertEqual(set(x.identifier for x in self.graph.contexts()), set([DATASET_DEFAULT_GRAPH_ID])) def testDefaultGraph(self): @@ -129,17 +129,17 @@ class DatasetTestCase(unittest.TestCase): "is supported by your SPARQL endpoint" self.graph.add(( self.tarek, self.likes, self.pizza)) - self.assertEquals(len(self.graph), 1) + self.assertEqual(len(self.graph), 1) # only default exists - self.assertEquals(set(x.identifier for x in self.graph.contexts()), + self.assertEqual(set(x.identifier for x in self.graph.contexts()), set([DATASET_DEFAULT_GRAPH_ID])) # removing default graph removes triples but not actual graph self.graph.remove_graph(DATASET_DEFAULT_GRAPH_ID) - self.assertEquals(len(self.graph), 0) + self.assertEqual(len(self.graph), 0) # default still exists - self.assertEquals(set(x.identifier for x in self.graph.contexts()), + self.assertEqual(set(x.identifier for x in self.graph.contexts()), set([DATASET_DEFAULT_GRAPH_ID])) def testNotUnion(self): diff --git a/test/test_datetime.py b/test/test_datetime.py index 7ba4de5d..5510bc4b 100644 --- a/test/test_datetime.py +++ b/test/test_datetime.py @@ -15,7 +15,7 @@ class TestRelativeBase(unittest.TestCase): def test_equality(self): x = Literal("2008-12-01T18:02:00Z", datatype=URIRef('http://www.w3.org/2001/XMLSchema#dateTime')) - self.assertEquals(x == x, True) + self.assertEqual(x == x, True) def test_microseconds(self): import platform @@ -27,8 +27,8 @@ class TestRelativeBase(unittest.TestCase): # datetime with microseconds should be cast as a literal with using # XML Schema dateTime as the literal datatype - self.assertEquals(unicode(l), '2009-06-15T23:37:06.522630') - self.assertEquals(l.datatype, XSD.dateTime) + self.assertEqual(unicode(l), '2009-06-15T23:37:06.522630') + self.assertEqual(l.datatype, XSD.dateTime) dt2 = l.toPython() self.assertEqual(dt2, dt1) @@ -38,19 +38,19 @@ class TestRelativeBase(unittest.TestCase): l = Literal(dt, datatype=URIRef('http://www.w3.org/2001/XMLSchema#dateTime')) - self.assert_(isinstance(l.toPython(), datetime)) - self.assertEquals(l.toPython().isoformat(), dt) + self.assertTrue(isinstance(l.toPython(), datetime)) + self.assertEqual(l.toPython().isoformat(), dt) def test_timezone_z(self): dt = "2008-12-01T18:02:00.522630Z" l = Literal(dt, datatype=URIRef('http://www.w3.org/2001/XMLSchema#dateTime')) - self.assert_(isinstance(l.toPython(), datetime)) - self.assertEquals(datetime_isoformat(l.toPython(), + self.assertTrue(isinstance(l.toPython(), datetime)) + self.assertEqual(datetime_isoformat(l.toPython(), DATE_EXT_COMPLETE + 'T' + '%H:%M:%S.%f' + TZ_EXT), dt) - self.assertEquals(l.toPython().isoformat(), + self.assertEqual(l.toPython().isoformat(), "2008-12-01T18:02:00.522630+00:00") def test_timezone_offset(self): @@ -58,8 +58,8 @@ class TestRelativeBase(unittest.TestCase): l = Literal(dt, datatype=URIRef('http://www.w3.org/2001/XMLSchema#dateTime')) - self.assert_(isinstance(l.toPython(), datetime)) - self.assertEquals(l.toPython().isoformat(), dt) + self.assertTrue(isinstance(l.toPython(), datetime)) + self.assertEqual(l.toPython().isoformat(), dt) def test_timezone_offset_to_utc(self): dt = "2010-02-10T12:36:00+03:00" @@ -67,7 +67,7 @@ class TestRelativeBase(unittest.TestCase): datatype=URIRef('http://www.w3.org/2001/XMLSchema#dateTime')) utc_dt = l.toPython().astimezone(UTC) - self.assertEquals(datetime_isoformat(utc_dt), + self.assertEqual(datetime_isoformat(utc_dt), "2010-02-10T09:36:00Z") def test_timezone_offset_millisecond(self): @@ -75,8 +75,8 @@ class TestRelativeBase(unittest.TestCase): l = Literal(dt, datatype=URIRef('http://www.w3.org/2001/XMLSchema#dateTime')) - self.assert_(isinstance(l.toPython(), datetime)) - self.assertEquals(l.toPython().isoformat(), dt) + self.assertTrue(isinstance(l.toPython(), datetime)) + self.assertEqual(l.toPython().isoformat(), dt) if __name__ == "__main__": unittest.main() diff --git a/test/test_dawg.py b/test/test_dawg.py index 3903ff09..bdacd992 100644 --- a/test/test_dawg.py +++ b/test/test_dawg.py @@ -432,7 +432,7 @@ def query_test(t): assert bindingsCompatible( set(res), set(res2) - ), 'Bindings do not match: \n%s\n!=\n%s' % ( + ), 'Bindings do not match: \nexpected:\n%s\n!=\ngot:\n%s' % ( res.serialize(format='txt', namespace_manager=g.namespace_manager), res2.serialize(format='txt', namespace_manager=g.namespace_manager)) elif res.type == 'ASK': diff --git a/test/test_graph.py b/test/test_graph.py index 6d1d0001..228550ec 100644 --- a/test/test_graph.py +++ b/test/test_graph.py @@ -91,7 +91,7 @@ class GraphTestCase(unittest.TestCase): hates = self.hates pizza = self.pizza cheese = self.cheese - asserte = self.assertEquals + asserte = self.assertEqual triples = self.graph.triples Any = None @@ -137,14 +137,14 @@ class GraphTestCase(unittest.TestCase): def testConnected(self): graph = self.graph self.addStuff() - self.assertEquals(True, graph.connected()) + self.assertEqual(True, graph.connected()) jeroen = URIRef("jeroen") unconnected = URIRef("unconnected") graph.add((jeroen, self.likes, unconnected)) - self.assertEquals(False, graph.connected()) + self.assertEqual(False, graph.connected()) def testSub(self): g1 = self.graph @@ -165,19 +165,19 @@ class GraphTestCase(unittest.TestCase): g3 = g1 - g2 - self.assertEquals(len(g3), 1) - self.assertEquals((tarek, likes, pizza) in g3, True) - self.assertEquals((tarek, likes, cheese) in g3, False) + self.assertEqual(len(g3), 1) + self.assertEqual((tarek, likes, pizza) in g3, True) + self.assertEqual((tarek, likes, cheese) in g3, False) - self.assertEquals((bob, likes, cheese) in g3, False) + self.assertEqual((bob, likes, cheese) in g3, False) g1 -= g2 - self.assertEquals(len(g1), 1) - self.assertEquals((tarek, likes, pizza) in g1, True) - self.assertEquals((tarek, likes, cheese) in g1, False) + self.assertEqual(len(g1), 1) + self.assertEqual((tarek, likes, pizza) in g1, True) + self.assertEqual((tarek, likes, cheese) in g1, False) - self.assertEquals((bob, likes, cheese) in g1, False) + self.assertEqual((bob, likes, cheese) in g1, False) def testGraphAdd(self): g1 = self.graph @@ -197,19 +197,19 @@ class GraphTestCase(unittest.TestCase): g3 = g1 + g2 - self.assertEquals(len(g3), 2) - self.assertEquals((tarek, likes, pizza) in g3, True) - self.assertEquals((tarek, likes, cheese) in g3, False) + self.assertEqual(len(g3), 2) + self.assertEqual((tarek, likes, pizza) in g3, True) + self.assertEqual((tarek, likes, cheese) in g3, False) - self.assertEquals((bob, likes, cheese) in g3, True) + self.assertEqual((bob, likes, cheese) in g3, True) g1 += g2 - self.assertEquals(len(g1), 2) - self.assertEquals((tarek, likes, pizza) in g1, True) - self.assertEquals((tarek, likes, cheese) in g1, False) + self.assertEqual(len(g1), 2) + self.assertEqual((tarek, likes, pizza) in g1, True) + self.assertEqual((tarek, likes, cheese) in g1, False) - self.assertEquals((bob, likes, cheese) in g1, True) + self.assertEqual((bob, likes, cheese) in g1, True) def testGraphIntersection(self): g1 = self.graph @@ -231,24 +231,24 @@ class GraphTestCase(unittest.TestCase): g3 = g1 * g2 - self.assertEquals(len(g3), 1) - self.assertEquals((tarek, likes, pizza) in g3, False) - self.assertEquals((tarek, likes, cheese) in g3, False) + self.assertEqual(len(g3), 1) + self.assertEqual((tarek, likes, pizza) in g3, False) + self.assertEqual((tarek, likes, cheese) in g3, False) - self.assertEquals((bob, likes, cheese) in g3, False) + self.assertEqual((bob, likes, cheese) in g3, False) - self.assertEquals((michel, likes, cheese) in g3, True) + self.assertEqual((michel, likes, cheese) in g3, True) g1 *= g2 - self.assertEquals(len(g1), 1) + self.assertEqual(len(g1), 1) - self.assertEquals((tarek, likes, pizza) in g1, False) - self.assertEquals((tarek, likes, cheese) in g1, False) + self.assertEqual((tarek, likes, pizza) in g1, False) + self.assertEqual((tarek, likes, cheese) in g1, False) - self.assertEquals((bob, likes, cheese) in g1, False) + self.assertEqual((bob, likes, cheese) in g1, False) - self.assertEquals((michel, likes, cheese) in g1, True) + self.assertEqual((michel, likes, cheese) in g1, True) # dynamically create classes for each registered Store diff --git a/test/test_graph_context.py b/test/test_graph_context.py index fce1626d..940921da 100644 --- a/test/test_graph_context.py +++ b/test/test_graph_context.py @@ -107,7 +107,7 @@ class ContextTestCase(unittest.TestCase): # add to context 1 graph = Graph(self.graph.store, self.c1) graph.add(triple) - self.assertEquals(len(self.graph), len(graph)) + self.assertEqual(len(self.graph), len(graph)) def testAdd(self): self.addStuff() @@ -126,11 +126,11 @@ class ContextTestCase(unittest.TestCase): for i in range(0, 10): graph.add((BNode(), self.hates, self.hates)) - self.assertEquals(len(graph), oldLen + 10) - self.assertEquals(len(self.graph.get_context(c1)), oldLen + 10) + self.assertEqual(len(graph), oldLen + 10) + self.assertEqual(len(self.graph.get_context(c1)), oldLen + 10) self.graph.remove_context(self.graph.get_context(c1)) - self.assertEquals(len(self.graph), oldLen) - self.assertEquals(len(graph), 0) + self.assertEqual(len(self.graph), oldLen) + self.assertEqual(len(graph), 0) def testLenInMultipleContexts(self): if self.store == "SQLite": @@ -140,10 +140,10 @@ class ContextTestCase(unittest.TestCase): # addStuffInMultipleContexts is adding the same triple to # three different contexts. So it's only + 1 - self.assertEquals(len(self.graph), oldLen + 1) + self.assertEqual(len(self.graph), oldLen + 1) graph = Graph(self.graph.store, self.c1) - self.assertEquals(len(graph), oldLen + 1) + self.assertEqual(len(graph), oldLen + 1) def testRemoveInMultipleContexts(self): c1 = self.c1 @@ -153,21 +153,21 @@ class ContextTestCase(unittest.TestCase): self.addStuffInMultipleContexts() # triple should be still in store after removing it from c1 + c2 - self.assert_(triple in self.graph) + self.assertTrue(triple in self.graph) graph = Graph(self.graph.store, c1) graph.remove(triple) - self.assert_(triple in self.graph) + self.assertTrue(triple in self.graph) graph = Graph(self.graph.store, c2) graph.remove(triple) - self.assert_(triple in self.graph) + self.assertTrue(triple in self.graph) self.graph.remove(triple) # now gone! - self.assert_(triple not in self.graph) + self.assertTrue(triple not in self.graph) # add again and see if remove without context removes all triples! self.addStuffInMultipleContexts() self.graph.remove(triple) - self.assert_(triple not in self.graph) + self.assertTrue(triple not in self.graph) def testContexts(self): triple = (self.pizza, self.hates, self.tarek) # revenge! @@ -176,28 +176,28 @@ class ContextTestCase(unittest.TestCase): def cid(c): return c.identifier - self.assert_(self.c1 in map(cid, self.graph.contexts())) - self.assert_(self.c2 in map(cid, self.graph.contexts())) + self.assertTrue(self.c1 in map(cid, self.graph.contexts())) + self.assertTrue(self.c2 in map(cid, self.graph.contexts())) contextList = map(cid, list(self.graph.contexts(triple))) - self.assert_(self.c1 in contextList) - self.assert_(self.c2 in contextList) + self.assertTrue(self.c1 in contextList) + self.assertTrue(self.c2 in contextList) def testRemoveContext(self): c1 = self.c1 self.addStuffInMultipleContexts() - self.assertEquals(len(Graph(self.graph.store, c1)), 1) - self.assertEquals(len(self.graph.get_context(c1)), 1) + self.assertEqual(len(Graph(self.graph.store, c1)), 1) + self.assertEqual(len(self.graph.get_context(c1)), 1) self.graph.remove_context(self.graph.get_context(c1)) - self.assert_(self.c1 not in self.graph.contexts()) + self.assertTrue(self.c1 not in self.graph.contexts()) def testRemoveAny(self): Any = None self.addStuffInMultipleContexts() self.graph.remove((Any, Any, Any)) - self.assertEquals(len(self.graph), 0) + self.assertEqual(len(self.graph), 0) def testTriples(self): tarek = self.tarek @@ -208,7 +208,7 @@ class ContextTestCase(unittest.TestCase): pizza = self.pizza cheese = self.cheese c1 = self.c1 - asserte = self.assertEquals + asserte = self.assertEqual triples = self.graph.triples graph = self.graph c1graph = Graph(self.graph.store, c1) diff --git a/test/test_initbindings.py b/test/test_initbindings.py index ad94db4f..e44f9fff 100644 --- a/test/test_initbindings.py +++ b/test/test_initbindings.py @@ -150,6 +150,9 @@ def testVariableKeyWithQuestionMark(): results = list(g2.query("SELECT ?o WHERE { ?s :p ?o }", initBindings={Variable("?s"): EX['s1']})) assert len(results) == 1, results +def testFilter(): + results = list(g2.query("SELECT ?o WHERE { ?s :p ?o FILTER (?s = ?x)}", initBindings={Variable("?x"): EX['s1']})) + assert len(results) == 1, results if __name__ == "__main__": diff --git a/test/test_issue130.py b/test/test_issue130.py deleted file mode 100644 index 0b0f81f9..00000000 --- a/test/test_issue130.py +++ /dev/null @@ -1,18 +0,0 @@ -import platform -import rdflib -from nose.exc import SkipTest -from rdflib.py3compat import b -if platform.system == 'Java': - raise SkipTest("Skipped test, unicode issues in Jython") - - -def test_issue_130(): - raise SkipTest("Remote content change - skip for now") - g = rdflib.Graph() - try: - g.parse(location="http://linked-data.ru/example") - except: - raise SkipTest('Test data URL unparseable') - if len(g) == 0: - raise SkipTest('Test data URL empty of content') - assert b('rdf:about="http://semanticfuture.net/linked-data/example/#company"') in g.serialize(), g.serialize() diff --git a/test/test_issue161.py b/test/test_issue161.py index 5dab94f8..2925b7ce 100644 --- a/test/test_issue161.py +++ b/test/test_issue161.py @@ -31,7 +31,7 @@ class EntityTest(TestCase): # Shouldn't have got to here s=g.serialize(format="turtle") - self.assert_(b('@prefix _9') not in s) + self.assertTrue(b('@prefix _9') not in s) diff --git a/test/test_issue223.py b/test/test_issue223.py new file mode 100644 index 00000000..c12f4fa1 --- /dev/null +++ b/test/test_issue223.py @@ -0,0 +1,19 @@ +from rdflib.graph import Graph +from rdflib.term import URIRef +from rdflib.collection import Collection + +ttl = """ +@prefix : <http://example.org/>. + +:s :p (:a :b :a). +""" +def test_collection_with_duplicates(): + g = Graph().parse(data=ttl, format="turtle") + for _,_,o in g.triples((URIRef("http://example.org/s"), URIRef("http://example.org/p"), None)): + break + c = g.collection(o) + assert list(c) == list(URIRef("http://example.org/" + x) for x in ["a", "b", "a"]) + assert len(c) == 3 + +if __name__ == '__main__': + test_collection_with_duplicates() diff --git a/test/test_issue248.py b/test/test_issue248.py index 7e39ba66..252b8a17 100644 --- a/test/test_issue248.py +++ b/test/test_issue248.py @@ -88,7 +88,7 @@ class TestSerialization(unittest.TestCase): sg = graph.serialize(format='n3', base=LCCO).decode('utf8') # See issue 248 # Actual test should be the inverse of the below ... - self.assert_('<1> a skos:Concept ;' in sg, sg) + self.assertTrue('<1> a skos:Concept ;' in sg, sg) if __name__ == "__main__": unittest.main() diff --git a/test/test_literal.py b/test/test_literal.py index b31a7e90..10cbba24 100644 --- a/test/test_literal.py +++ b/test/test_literal.py @@ -12,12 +12,12 @@ class TestLiteral(unittest.TestCase): def test_repr_apostrophe(self): a = rdflib.Literal("'") b = eval(repr(a)) - self.assertEquals(a, b) + self.assertEqual(a, b) def test_repr_quote(self): a = rdflib.Literal('"') b = eval(repr(a)) - self.assertEquals(a, b) + self.assertEqual(a, b) def test_backslash(self): d = r""" @@ -33,11 +33,11 @@ class TestLiteral(unittest.TestCase): g.parse(data=d) a = rdflib.Literal('a\\b') b = list(g.objects())[0] - self.assertEquals(a, b) + self.assertEqual(a, b) def test_literal_from_bool(self): l = rdflib.Literal(True) - self.assertEquals(l.datatype, rdflib.XSD["boolean"]) + self.assertEqual(l.datatype, rdflib.XSD["boolean"]) class TestNew(unittest.TestCase): def testCantPassLangAndDatatype(self): @@ -61,7 +61,7 @@ class TestNew(unittest.TestCase): # drewp disapproves of this behavior, but it should be # represented in the tests x = Literal("foo", datatype="http://example.com/") - self.assert_(isinstance(x.datatype, URIRef)) + self.assertTrue(isinstance(x.datatype, URIRef)) x = Literal("foo", datatype=Literal("pennies")) self.assertEqual(x.datatype, URIRef("pennies")) @@ -93,7 +93,7 @@ class TestDoubleOutput(unittest.TestCase): """confirms the fix for https://github.com/RDFLib/rdflib/issues/237""" vv = Literal("0.88", datatype=_XSD_DOUBLE) out = vv._literal_n3(use_plain=True) - self.assert_(out in ["8.8e-01", "0.88"], out) + self.assertTrue(out in ["8.8e-01", "0.88"], out) class TestBindings(unittest.TestCase): diff --git a/test/test_memory_store.py b/test/test_memory_store.py index 403a3acc..0fb6c82d 100644 --- a/test/test_memory_store.py +++ b/test/test_memory_store.py @@ -16,13 +16,13 @@ class StoreTestCase(unittest.TestCase): rdflib.URIRef("http://example.org/foo#bar4"), rdflib.URIRef("http://example.org/foo#bar5")) g.add(triple1) - self.assert_(len(g) == 1) + self.assertTrue(len(g) == 1) g.add(triple2) - self.assert_(len(list(g.triples((subj1, None, None)))) == 2) - self.assert_(len(list(g.triples((None, pred1, None)))) == 1) - self.assert_(len(list(g.triples((None, None, obj1)))) == 1) + self.assertTrue(len(list(g.triples((subj1, None, None)))) == 2) + self.assertTrue(len(list(g.triples((None, pred1, None)))) == 1) + self.assertTrue(len(list(g.triples((None, None, obj1)))) == 1) g.remove(triple1) - self.assert_(len(g) == 1) + self.assertTrue(len(g) == 1) g.serialize() diff --git a/test/test_n3.py b/test/test_n3.py index 3255df25..7520fc81 100644 --- a/test/test_n3.py +++ b/test/test_n3.py @@ -182,8 +182,8 @@ foo-bar:Ex foo-bar:name "Test" . """ for s, p, o in g: if isinstance(s, Graph): i += 1 - self.assertEquals(i, 3) - self.assertEquals(len(list(g.contexts())), 13) + self.assertEqual(i, 3) + self.assertEqual(len(list(g.contexts())), 13) g.close() diff --git a/test/test_nodepickler.py b/test/test_nodepickler.py index 70e54644..c2dbbac9 100644 --- a/test/test_nodepickler.py +++ b/test/test_nodepickler.py @@ -31,7 +31,7 @@ class UtilTestCase(unittest.TestCase): a = Literal(u'''A test with a \\n (backslash n), "\u00a9" , and newline \n and a second line. ''') b = np.loads(np.dumps(a)) - self.assertEquals(a, b) + self.assertEqual(a, b) def test_literal_cases(self): np = NodePickler() @@ -39,14 +39,14 @@ class UtilTestCase(unittest.TestCase): for l in cases: a = Literal(l) b = np.loads(np.dumps(a)) - self.assertEquals(a, b) + self.assertEqual(a, b) def test_pickle(self): np = NodePickler() dump = pickle.dumps(np) np2 = pickle.loads(dump) - self.assertEquals(np._ids, np2._ids) - self.assertEquals(np._objects, np2._objects) + self.assertEqual(np._ids, np2._ids) + self.assertEqual(np._objects, np2._objects) if __name__ == '__main__': diff --git a/test/test_nt_misc.py b/test/test_nt_misc.py index e267ffa5..486354c7 100644 --- a/test/test_nt_misc.py +++ b/test/test_nt_misc.py @@ -13,7 +13,7 @@ class NTTestCase(unittest.TestCase): g = Graph() g.add((URIRef("foo"), URIRef("foo"), Literal(u"R\u00E4ksm\u00F6rg\u00E5s"))) s = g.serialize(format='nt') - self.assertEquals(type(s), bytestype) + self.assertEqual(type(s), bytestype) self.assertTrue(b(r"R\u00E4ksm\u00F6rg\u00E5s") in s) def testIssue146(self): @@ -24,15 +24,15 @@ class NTTestCase(unittest.TestCase): def test_sink(self): s = ntriples.Sink() - self.assert_(s.length == 0) + self.assertTrue(s.length == 0) s.triple(None, None, None) - self.assert_(s.length == 1) + self.assertTrue(s.length == 1) def test_nonvalidating_unquote(self): safe = """<http://example.org/alice/foaf.rdf#me> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> <http://example.org/alice/foaf1.rdf> .""" ntriples.validate = False res = ntriples.unquote(safe) - self.assert_(isinstance(res, unicode)) + self.assertTrue(isinstance(res, unicode)) def test_validating_unquote(self): quot = """<http://example.org/alice/foaf.rdf#me> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> <http://example.org/alice/foaf1.rdf> .""" @@ -55,7 +55,7 @@ class NTTestCase(unittest.TestCase): ntriples.validate = False safe = """<http://example.org/alice/foaf.rdf#me> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> <http://example.org/alice/foaf1.rdf> .""" res = ntriples.uriquote(safe) - self.assert_(res == safe) + self.assertTrue(res == safe) def test_validating_uriquote(self): ntriples.validate = True @@ -79,7 +79,7 @@ class NTTestCase(unittest.TestCase): data = f.read() p = ntriples.NTriplesParser() res = p.parsestring(data) - self.assert_(res == None) + self.assertTrue(res == None) def test_w3_ntriple_variants(self): uri = "file:///"+os.getcwd()+"/test/nt/test.ntriples" @@ -89,7 +89,7 @@ class NTTestCase(unittest.TestCase): sink = parser.parse(u) u.close() # ATM we are only really interested in any exceptions thrown - self.assert_(sink is not None) + self.assertTrue(sink is not None) def test_bad_line(self): data = '''<http://example.org/resource32> 3 <http://example.org/datatype1> .\n''' diff --git a/test/test_parser.py b/test/test_parser.py index 622b83a0..d311a89b 100644 --- a/test/test_parser.py +++ b/test/test_parser.py @@ -35,9 +35,9 @@ class ParserTestCase(unittest.TestCase): subject = URIRef("http://example.org#") label = g.value(subject, RDFS.label) - self.assertEquals(label, Literal("testing")) + self.assertEqual(label, Literal("testing")) type = g.value(subject, RDF.type) - self.assertEquals(type, RDFS.Class) + self.assertEqual(type, RDFS.Class) if __name__ == "__main__": diff --git a/test/test_rdf_lists.py b/test/test_rdf_lists.py index 3403c8f1..b8286310 100644 --- a/test/test_rdf_lists.py +++ b/test/test_rdf_lists.py @@ -45,7 +45,7 @@ class OWLCollectionTest(unittest.TestCase): class ListTest(unittest.TestCase): def testFalseElement(self): g=Graph().parse(data=DATA_FALSE_ELEMENT, format='nt') - self.assertEquals(len(list(g.items(URIRef('http://example.org/#ThreeMemberList')))), 3) + self.assertEqual(len(list(g.items(URIRef('http://example.org/#ThreeMemberList')))), 3) if __name__ == '__main__': diff --git a/test/test_rdfxml.py b/test/test_rdfxml.py index e01eb910..f8322b33 100644 --- a/test/test_rdfxml.py +++ b/test/test_rdfxml.py @@ -185,7 +185,7 @@ class ParserTestCase(unittest.TestCase): result = _testNegative(neg, manifest) total += 1 num_failed += result - self.assertEquals( + self.assertEqual( num_failed, 0, "Failed: %s of %s." % (num_failed, total)) def testPositive(self): @@ -210,7 +210,7 @@ class ParserTestCase(unittest.TestCase): results.add((test, RDF.type, RESULT["FailingRun"])) total += 1 num_failed += result - self.assertEquals( + self.assertEqual( num_failed, 0, "Failed: %s of %s." % (num_failed, total)) RESULT = Namespace("http://www.w3.org/2002/03owlt/resultsOntology#") diff --git a/test/test_seq.py b/test/test_seq.py index 6e99e3e0..585a1062 100644 --- a/test/test_seq.py +++ b/test/test_seq.py @@ -37,9 +37,9 @@ class SeqTestCase(unittest.TestCase): def testSeq(self): items = self.store.seq(URIRef("http://example.org/Seq")) - self.assertEquals(len(items), 6) - self.assertEquals(items[-1], URIRef("http://example.org/six")) - self.assertEquals(items[2], URIRef("http://example.org/three")) + self.assertEqual(len(items), 6) + self.assertEqual(items[-1], URIRef("http://example.org/six")) + self.assertEqual(items[2], URIRef("http://example.org/three")) # just make sure we can serialize self.store.serialize() diff --git a/test/test_slice.py b/test/test_slice.py index 2371b79c..2b02266c 100644 --- a/test/test_slice.py +++ b/test/test_slice.py @@ -12,8 +12,8 @@ class GraphSlice(unittest.TestCase): all operations return generators over full triples """ - sl=lambda x,y: self.assertEquals(len(list(x)),y) - soe=lambda x,y: self.assertEquals(set([a[2] for a in x]),set(y)) # equals objects + sl=lambda x,y: self.assertEqual(len(list(x)),y) + soe=lambda x,y: self.assertEqual(set([a[2] for a in x]),set(y)) # equals objects g=self.graph # Single terms are all trivial: diff --git a/test/test_sparqlupdatestore.py b/test/test_sparqlupdatestore.py index 39678cc6..152f4bb2 100644 --- a/test/test_sparqlupdatestore.py +++ b/test/test_sparqlupdatestore.py @@ -58,30 +58,30 @@ class TestSparql11(unittest.TestCase): g2 = self.graph.get_context(othergraphuri) g2.add((michel, likes, pizza)) - self.assertEquals(3, len(g), 'graph contains 3 triples') - self.assertEquals(1, len(g2), 'other graph contains 1 triple') + self.assertEqual(3, len(g), 'graph contains 3 triples') + self.assertEqual(1, len(g2), 'other graph contains 1 triple') r = g.query("SELECT * WHERE { ?s <urn:likes> <urn:pizza> . }") - self.assertEquals(2, len(list(r)), "two people like pizza") + self.assertEqual(2, len(list(r)), "two people like pizza") r = g.triples((None, likes, pizza)) - self.assertEquals(2, len(list(r)), "two people like pizza") + self.assertEqual(2, len(list(r)), "two people like pizza") # Test initBindings r = g.query("SELECT * WHERE { ?s <urn:likes> <urn:pizza> . }", initBindings={'s': tarek}) - self.assertEquals(1, len(list(r)), "i was asking only about tarek") + self.assertEqual(1, len(list(r)), "i was asking only about tarek") r = g.triples((tarek, likes, pizza)) - self.assertEquals(1, len(list(r)), "i was asking only about tarek") + self.assertEqual(1, len(list(r)), "i was asking only about tarek") r = g.triples((tarek, likes, cheese)) - self.assertEquals(0, len(list(r)), "tarek doesn't like cheese") + self.assertEqual(0, len(list(r)), "tarek doesn't like cheese") g2.add((tarek, likes, pizza)) g.remove((tarek, likes, pizza)) r = g.query("SELECT * WHERE { ?s <urn:likes> <urn:pizza> . }") - self.assertEquals(1, len(list(r)), "only bob likes pizza") + self.assertEqual(1, len(list(r)), "only bob likes pizza") def testConjunctiveDefault(self): g = self.graph.get_context(graphuri) @@ -90,7 +90,7 @@ class TestSparql11(unittest.TestCase): g2.add((bob, likes, pizza)) g.add((tarek, hates, cheese)) - self.assertEquals(2, len(g), 'graph contains 2 triples') + self.assertEqual(2, len(g), 'graph contains 2 triples') # the following are actually bad tests as they depend on your endpoint, # as pointed out in the sparqlstore.py code: @@ -102,33 +102,33 @@ class TestSparql11(unittest.TestCase): ## ## Fuseki/TDB has a flag for specifying that the default graph ## is the union of all graphs (tdb:unionDefaultGraph in the Fuseki config). - self.assertEquals(3, len(self.graph), + self.assertEqual(3, len(self.graph), 'default union graph should contain three triples but contains:\n' '%s' % list(self.graph)) r = self.graph.query("SELECT * WHERE { ?s <urn:likes> <urn:pizza> . }") - self.assertEquals(2, len(list(r)), "two people like pizza") + self.assertEqual(2, len(list(r)), "two people like pizza") r = self.graph.query("SELECT * WHERE { ?s <urn:likes> <urn:pizza> . }", initBindings={'s': tarek}) - self.assertEquals(1, len(list(r)), "i was asking only about tarek") + self.assertEqual(1, len(list(r)), "i was asking only about tarek") r = self.graph.triples((tarek, likes, pizza)) - self.assertEquals(1, len(list(r)), "i was asking only about tarek") + self.assertEqual(1, len(list(r)), "i was asking only about tarek") r = self.graph.triples((tarek, likes, cheese)) - self.assertEquals(0, len(list(r)), "tarek doesn't like cheese") + self.assertEqual(0, len(list(r)), "tarek doesn't like cheese") g2.remove((bob, likes, pizza)) r = self.graph.query("SELECT * WHERE { ?s <urn:likes> <urn:pizza> . }") - self.assertEquals(1, len(list(r)), "only tarek likes pizza") + self.assertEqual(1, len(list(r)), "only tarek likes pizza") def testUpdate(self): self.graph.update("INSERT DATA { GRAPH <urn:graph> { <urn:michel> <urn:likes> <urn:pizza> . } }") g = self.graph.get_context(graphuri) - self.assertEquals(1, len(g), 'graph contains 1 triples') + self.assertEqual(1, len(g), 'graph contains 1 triples') def testUpdateWithInitNs(self): self.graph.update( @@ -137,7 +137,7 @@ class TestSparql11(unittest.TestCase): ) g = self.graph.get_context(graphuri) - self.assertEquals( + self.assertEqual( set(g.triples((None,None,None))), set([(michel,likes,pizza)]), 'only michel likes pizza' @@ -154,7 +154,7 @@ class TestSparql11(unittest.TestCase): ) g = self.graph.get_context(graphuri) - self.assertEquals( + self.assertEqual( set(g.triples((None,None,None))), set([(michel,likes,pizza)]), 'only michel likes pizza' @@ -173,7 +173,7 @@ class TestSparql11(unittest.TestCase): ) g = self.graph.get_context(graphuri) - self.assertEquals( + self.assertEqual( set(g.triples((None,None,None))), set([(michel,likes,pizza), (bob,likes,pizza)]), 'michel and bob like pizza' @@ -183,7 +183,7 @@ class TestSparql11(unittest.TestCase): g = self.graph.get_context(graphuri) r1 = "INSERT DATA { <urn:michel> <urn:likes> <urn:pizza> }" g.update(r1) - self.assertEquals( + self.assertEqual( set(g.triples((None,None,None))), set([(michel,likes,pizza)]), 'only michel likes pizza' @@ -192,7 +192,7 @@ class TestSparql11(unittest.TestCase): r2 = "DELETE { <urn:michel> <urn:likes> <urn:pizza> } " + \ "INSERT { <urn:bob> <urn:likes> <urn:pizza> } WHERE {}" g.update(r2) - self.assertEquals( + self.assertEqual( set(g.triples((None, None, None))), set([(bob, likes, pizza)]), 'only bob likes pizza' @@ -210,7 +210,7 @@ class TestSparql11(unittest.TestCase): values = set() for v in g.objects(bob, says): values.add(str(v)) - self.assertEquals(values, set(tricky_strs)) + self.assertEqual(values, set(tricky_strs)) # Complicated Strings r4strings = [] @@ -236,7 +236,7 @@ class TestSparql11(unittest.TestCase): values = set() for v in g.objects(michel, says): values.add(unicode(v)) - self.assertEquals(values, set([re.sub(ur"\\(.)", ur"\1", re.sub(ur"^'''|'''$|^'|'$|" + ur'^"""|"""$|^"|"$', ur"", s)) for s in r4strings])) + self.assertEqual(values, set([re.sub(ur"\\(.)", ur"\1", re.sub(ur"^'''|'''$|^'|'$|" + ur'^"""|"""$|^"|"$', ur"", s)) for s in r4strings])) # IRI Containing ' or # # The fragment identifier must not be misinterpreted as a comment @@ -249,7 +249,7 @@ class TestSparql11(unittest.TestCase): values = set() for v in g.objects(michel, hates): values.add(unicode(v)) - self.assertEquals(values, set([u"urn:foo'bar?baz;a=1&b=2#fragment", u"'}"])) + self.assertEqual(values, set([u"urn:foo'bar?baz;a=1&b=2#fragment", u"'}"])) # Comments r6 = u""" @@ -263,7 +263,7 @@ class TestSparql11(unittest.TestCase): values = set() for v in g.objects(bob, hates): values.add(v) - self.assertEquals(values, set([bob, michel])) + self.assertEqual(values, set([bob, michel])) def testNamedGraphUpdateWithInitBindings(self): g = self.graph.get_context(graphuri) @@ -273,7 +273,7 @@ class TestSparql11(unittest.TestCase): 'b': likes, 'c': pizza }) - self.assertEquals( + self.assertEqual( set(g.triples((None, None, None))), set([(michel, likes, pizza)]), 'only michel likes pizza' @@ -300,7 +300,7 @@ class TestSparql11(unittest.TestCase): Literal(''))) o = tuple(g)[0][2] - self.assertEquals(o, Literal(''), repr(o)) + self.assertEqual(o, Literal(''), repr(o)) from nose import SkipTest import urllib2 diff --git a/test/test_term.py b/test/test_term.py index 31d5eab1..78fa7a03 100644 --- a/test/test_term.py +++ b/test/test_term.py @@ -3,9 +3,12 @@ some more specific Literal tests are in test_literal.py """ import unittest +import base64 + from rdflib.py3compat import format_doctest_out as uformat -from rdflib.term import URIRef, BNode +from rdflib.term import URIRef, BNode, Literal, _is_valid_unicode from rdflib.graph import QuotedGraph, Graph +from rdflib.namespace import XSD class TestURIRefRepr(unittest.TestCase): """ @@ -25,15 +28,38 @@ class TestURIRefRepr(unittest.TestCase): a = u>BNode() a = u>QuotedGraph(g.store, u) a = u>g - - - - + class TestBNodeRepr(unittest.TestCase): - + def testSubclassNameAppearsInRepr(self): class MyBNode(BNode): pass x = MyBNode() - self.assert_(repr(x).startswith("MyBNode(")) + self.assertTrue(repr(x).startswith("MyBNode(")) + + +class TestLiteral(unittest.TestCase): + + def test_base64_values(self): + b64msg = 'cmRmbGliIGlzIGNvb2whIGFsc28gaGVyZSdzIHNvbWUgYmluYXJ5IAAR83UC' + decoded_b64msg = base64.b64decode(b64msg) + lit = Literal(b64msg, datatype=XSD.base64Binary) + self.assertEqual(lit.value, decoded_b64msg) + self.assertEqual(str(lit), b64msg) + + +class TestValidityFunctions(unittest.TestCase): + + def test_is_valid_unicode(self): + testcase_list = ( + (None, True), + (1, True), + (['foo'], True), + ({'foo': b'bar'}, True), + ('foo', True), + (b'foo\x00', True), + (b'foo\xf3\x02', False) + ) + for val, expected in testcase_list: + self.assertEqual(_is_valid_unicode(val), expected) diff --git a/test/test_trig.py b/test/test_trig.py index e05f483e..8b3bd68f 100644 --- a/test/test_trig.py +++ b/test/test_trig.py @@ -2,6 +2,7 @@ import unittest import rdflib import re +from nose import SkipTest from rdflib.py3compat import b TRIPLE = (rdflib.URIRef("http://example.com/s"), @@ -29,7 +30,7 @@ class TestTrig(unittest.TestCase): self.assertEqual(len(g.get_context('urn:b')),1) s=g.serialize(format='trig') - self.assert_(b('{}') not in s) # no empty graphs! + self.assertTrue(b('{}') not in s) # no empty graphs! def testSameSubject(self): g=rdflib.ConjunctiveGraph() @@ -49,7 +50,7 @@ class TestTrig(unittest.TestCase): self.assertEqual(len(re.findall(b("p1"), s)), 1) self.assertEqual(len(re.findall(b("p2"), s)), 1) - self.assert_(b('{}') not in s) # no empty graphs! + self.assertTrue(b('{}') not in s) # no empty graphs! def testRememberNamespace(self): g = rdflib.ConjunctiveGraph() @@ -58,14 +59,14 @@ class TestTrig(unittest.TestCase): # prefix for the graph but later serialize() calls would work. first_out = g.serialize(format='trig') second_out = g.serialize(format='trig') - self.assert_(b'@prefix ns1: <http://example.com/> .' in second_out) - self.assert_(b'@prefix ns1: <http://example.com/> .' in first_out) + self.assertTrue(b'@prefix ns1: <http://example.com/> .' in second_out) + self.assertTrue(b'@prefix ns1: <http://example.com/> .' in first_out) def testGraphQnameSyntax(self): g = rdflib.ConjunctiveGraph() g.add(TRIPLE + (rdflib.URIRef("http://example.com/graph1"),)) out = g.serialize(format='trig') - self.assert_(b'ns1:graph1 {' in out) + self.assertTrue(b'ns1:graph1 {' in out) def testGraphUriSyntax(self): g = rdflib.ConjunctiveGraph() @@ -73,12 +74,106 @@ class TestTrig(unittest.TestCase): # a '<...>' term. g.add(TRIPLE + (rdflib.URIRef("http://example.com/foo."),)) out = g.serialize(format='trig') - self.assert_(b'<http://example.com/foo.> {' in out) + self.assertTrue(b'<http://example.com/foo.> {' in out) def testBlankGraphIdentifier(self): g = rdflib.ConjunctiveGraph() g.add(TRIPLE + (rdflib.BNode(),)) out = g.serialize(format='trig') graph_label_line = out.splitlines()[-4] - self.assert_(re.match(br'^_:[a-zA-Z0-9]+ \{', graph_label_line)) - + + self.assertTrue(re.match(br'^_:[a-zA-Z0-9]+ \{', graph_label_line)) + + def testGraphParsing(self): + # should parse into single default graph context + data = """ +<http://example.com/thing#thing_a> <http://example.com/knows> <http://example.com/thing#thing_b> . +""" + g = rdflib.ConjunctiveGraph() + g.parse(data=data, format='trig') + self.assertEqual(len(list(g.contexts())), 1) + + # should parse into single default graph context + data = """ +<http://example.com/thing#thing_a> <http://example.com/knows> <http://example.com/thing#thing_b> . + +{ <http://example.com/thing#thing_c> <http://example.com/knows> <http://example.com/thing#thing_d> . } +""" + g = rdflib.ConjunctiveGraph() + g.parse(data=data, format='trig') + self.assertEqual(len(list(g.contexts())), 1) + + # should parse into 2 contexts, one default, one named + data = """ +<http://example.com/thing#thing_a> <http://example.com/knows> <http://example.com/thing#thing_b> . + +{ <http://example.com/thing#thing_c> <http://example.com/knows> <http://example.com/thing#thing_d> . } + +<http://example.com/graph#graph_a> { + <http://example.com/thing/thing_e> <http://example.com/knows> <http://example.com/thing#thing_f> . +} +""" + g = rdflib.ConjunctiveGraph() + g.parse(data=data, format='trig') + self.assertEqual(len(list(g.contexts())), 2) + + def testRoundTrips(self): + + raise SkipTest('skipped until 5.0') + + data = """ +<http://example.com/thing#thing_a> <http://example.com/knows> <http://example.com/thing#thing_b> . + +{ <http://example.com/thing#thing_c> <http://example.com/knows> <http://example.com/thing#thing_d> . } + +<http://example.com/graph#graph_a> { + <http://example.com/thing/thing_e> <http://example.com/knows> <http://example.com/thing#thing_f> . +} +""" + g = rdflib.ConjunctiveGraph() + for i in range(5): + g.parse(data=data, format='trig') + data = g.serialize(format='trig') + + # output should only contain 1 mention of each resource/graph name + self.assertEqual(data.count('thing_a'), 1) + self.assertEqual(data.count('thing_b'), 1) + self.assertEqual(data.count('thing_c'), 1) + self.assertEqual(data.count('thing_d'), 1) + self.assertEqual(data.count('thing_e'), 1) + self.assertEqual(data.count('thing_f'), 1) + self.assertEqual(data.count('graph_a'), 1) + + def testDefaultGraphSerializesWithoutName(self): + data = """ +<http://example.com/thing#thing_a> <http://example.com/knows> <http://example.com/thing#thing_b> . + +{ <http://example.com/thing#thing_c> <http://example.com/knows> <http://example.com/thing#thing_d> . } +""" + g = rdflib.ConjunctiveGraph() + g.parse(data=data, format='trig') + data = g.serialize(format='trig') + + self.assertTrue(b('None') not in data) + + def testPrefixes(self): + + data = """ + @prefix ns1: <http://ex.org/schema#> . + <http://ex.org/docs/document1> = { + ns1:Person_A a ns1:Person ; + ns1:TextSpan "Simon" . + } + <http://ex.org/docs/document2> = { + ns1:Person_C a ns1:Person ; + ns1:TextSpan "Agnes" . + } + """ + + cg = rdflib.ConjunctiveGraph() + cg.parse(data=data, format='trig') + data = cg.serialize(format='trig') + + self.assert_(b('ns2: <http://ex.org/docs/') in data, data) + self.assert_(b('<ns2:document1>') not in data, data) + self.assert_(b('ns2:document1') in data, data) diff --git a/test/test_trix_parse.py b/test/test_trix_parse.py index 40c57507..225be937 100644 --- a/test/test_trix_parse.py +++ b/test/test_trix_parse.py @@ -22,8 +22,8 @@ class TestTrixParse(unittest.TestCase): #print list(g.contexts()) t=sum(map(len, g.contexts())) - self.assertEquals(t,24) - self.assertEquals(len(c),4) + self.assertEqual(t,24) + self.assertEqual(len(c),4) #print "Parsed %d triples"%t diff --git a/test/test_trix_serialize.py b/test/test_trix_serialize.py index c2bd631f..f2d589b1 100644 --- a/test/test_trix_serialize.py +++ b/test/test_trix_serialize.py @@ -60,7 +60,7 @@ class TestTrixSerialize(unittest.TestCase): # here I know there is only one anonymous graph, # and that is the default one, but this is not always the case tg = g.default_context - self.assert_(q[0:3] in tg) + self.assertTrue(q[0:3] in tg) def test_issue_250(self): """ @@ -93,9 +93,9 @@ class TestTrixSerialize(unittest.TestCase): graph = ConjunctiveGraph() graph.bind(None, "http://defaultnamespace") sg = graph.serialize(format='trix').decode('UTF-8') - self.assert_( + self.assertTrue( 'xmlns="http://defaultnamespace"' not in sg, sg) - self.assert_( + self.assertTrue( 'xmlns="http://www.w3.org/2004/03/trix/trix-1/' in sg, sg) diff --git a/test/test_turtle_sort_issue613.py b/test/test_turtle_sort_issue613.py new file mode 100644 index 00000000..813ce5b9 --- /dev/null +++ b/test/test_turtle_sort_issue613.py @@ -0,0 +1,39 @@ +import rdflib + +""" +In py3, some objects are not comparable. When the turtle serializer tries to sort them everything breaks. + +* Timezone aware datetime objects and "naive" datetime objects are not comparable + +https://github.com/RDFLib/rdflib/issues/648 +https://github.com/RDFLib/rdflib/issues/613 + +* DocumentFragment +https://github.com/RDFLib/rdflib/issues/676 + +""" + + +def test_sort_dates(): + + g = rdflib.Graph() + y = '''@prefix ex: <http://ex.org> . +ex:X ex:p "2016-01-01T00:00:00"^^<http://www.w3.org/2001/XMLSchema#dateTime>, "2016-01-01T00:00:00Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> . ''' + + p=g.parse(data=y, format="turtle") + p.serialize(format="turtle") + + +def test_sort_docfrag(): + + g = rdflib.Graph() + y = '''@prefix ex: <http://ex.org> . +@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . +ex:X ex:p "<h1>hi</h1>"^^rdf:HTML, "<h1>ho</h1>"^^rdf:HTML . ''' + + p=g.parse(data=y, format="turtle") + p.serialize(format="turtle") + +if __name__ == '__main__': + + test_sort_docfrag() diff --git a/test/test_util.py b/test/test_util.py index 0243c0c8..a95caa06 100644 --- a/test/test_util.py +++ b/test/test_util.py @@ -57,15 +57,15 @@ class TestUtilMisc(unittest.TestCase): def test_util_list2set(self): base = [Literal('foo'), self.x] r = util.list2set(base+base) - self.assert_(r == base) + self.assertTrue(r == base) def test_util_uniq(self): base = ["michel", "hates", "pizza"] r = util.uniq(base+base) - self.assertEquals(sorted(r), sorted(base)) + self.assertEqual(sorted(r), sorted(base)) base = ["michel", "hates", "pizza"] r = util.uniq(base+base, strip=True) - self.assertEquals(sorted(r), sorted(base)) + self.assertEqual(sorted(r), sorted(base)) def test_coverage_dodge(self): util.test() @@ -79,32 +79,32 @@ class TestUtilDateTime(unittest.TestCase): def test_util_date_time_tisnoneandnotz(self): t = None res = util.date_time(t, local_time_zone=False) - self.assert_(res[4:5] == "-") + self.assertTrue(res[4:5] == "-") def test_util_date_time_tisnonebuttz(self): t = None res = util.date_time(t, local_time_zone=True) - self.assert_(res[4:5] == "-") + self.assertTrue(res[4:5] == "-") def test_util_date_time_tistime(self): t = time.time() res = util.date_time(t, local_time_zone=False) - self.assert_(res[4:5] == "-") + self.assertTrue(res[4:5] == "-") def test_util_date_time_tistimewithtz(self): t = time.time() res = util.date_time(t, local_time_zone=True) - self.assert_(res[4:5] == "-") + self.assertTrue(res[4:5] == "-") def test_util_parse_date_time(self): t = time.time() res = util.parse_date_time("1970-01-01") - self.assert_(res is not t) + self.assertTrue(res is not t) def test_util_parse_date_timewithtz(self): t = time.time() res = util.parse_date_time("1970-01-01") - self.assert_(res is not t) + self.assertTrue(res is not t) def test_util_date_timewithtoutz(self): t = time.time() @@ -114,7 +114,7 @@ class TestUtilDateTime(unittest.TestCase): return res util.localtime = ablocaltime res = util.date_time(t, local_time_zone=True) - self.assert_(res is not t) + self.assertTrue(res is not t) class TestUtilTermConvert(unittest.TestCase): def setUp(self): @@ -123,25 +123,25 @@ class TestUtilTermConvert(unittest.TestCase): def test_util_to_term_sisNone(self): s = None - self.assertEquals(util.to_term(s), s) - self.assertEquals(util.to_term(s, default=""), "") + self.assertEqual(util.to_term(s), s) + self.assertEqual(util.to_term(s, default=""), "") def test_util_to_term_sisstr(self): s = '"http://example.com"' res = util.to_term(s) - self.assert_(isinstance(res, Literal)) - self.assertEquals(str(res), s[1:-1]) + self.assertTrue(isinstance(res, Literal)) + self.assertEqual(str(res), s[1:-1]) def test_util_to_term_sisurl(self): s = "<http://example.com>" res = util.to_term(s) - self.assert_(isinstance(res, URIRef)) - self.assertEquals(str(res), s[1:-1]) + self.assertTrue(isinstance(res, URIRef)) + self.assertEqual(str(res), s[1:-1]) def test_util_to_term_sisbnode(self): s = '_http%23%4F%4Fexample%33com' res = util.to_term(s) - self.assert_(isinstance(res, BNode)) + self.assertTrue(isinstance(res, BNode)) def test_util_to_term_sisunknown(self): s = 'http://example.com' @@ -155,44 +155,44 @@ class TestUtilTermConvert(unittest.TestCase): s = None default = None res = util.from_n3(s, default=default, backend=None) - self.assert_(res == default) + self.assertTrue(res == default) def test_util_from_n3_sisnonewithdefault(self): s = None default = "TestofDefault" res = util.from_n3(s, default=default, backend=None) - self.assert_(res == default) + self.assertTrue(res == default) def test_util_from_n3_expectdefaultbnode(self): s = "michel" res = util.from_n3(s, default=None, backend=None) - self.assert_(isinstance(res, BNode)) + self.assertTrue(isinstance(res, BNode)) def test_util_from_n3_expectbnode(self): s = "_:michel" res = util.from_n3(s, default=None, backend=None) - self.assert_(isinstance(res, BNode)) + self.assertTrue(isinstance(res, BNode)) def test_util_from_n3_expectliteral(self): s = '"michel"' res = util.from_n3(s, default=None, backend=None) - self.assert_(isinstance(res, Literal)) + self.assertTrue(isinstance(res, Literal)) def test_util_from_n3_expecturiref(self): s = '<http://example.org/schema>' res = util.from_n3(s, default=None, backend=None) - self.assert_(isinstance(res, URIRef)) + self.assertTrue(isinstance(res, URIRef)) def test_util_from_n3_expectliteralandlang(self): s = '"michel"@fr' res = util.from_n3(s, default=None, backend=None) - self.assert_(isinstance(res, Literal)) + self.assertTrue(isinstance(res, Literal)) def test_util_from_n3_expectliteralandlangdtype(self): s = '"michel"@fr^^xsd:fr' res = util.from_n3(s, default=None, backend=None) - self.assert_(isinstance(res, Literal)) + self.assertTrue(isinstance(res, Literal)) self.assertEqual(res, Literal('michel', datatype=XSD['fr'])) @@ -217,18 +217,18 @@ class TestUtilTermConvert(unittest.TestCase): def test_util_from_n3_expectliteralmultiline(self): s = '"""multi\nline\nstring"""@en' res = util.from_n3(s, default=None, backend=None) - self.assert_(res, Literal('multi\nline\nstring', lang='en')) + self.assertTrue(res, Literal('multi\nline\nstring', lang='en')) def test_util_from_n3_expectliteralwithescapedquote(self): s = '"\\""' res = util.from_n3(s, default=None, backend=None) - self.assert_(res, Literal('\\"', lang='en')) + self.assertTrue(res, Literal('\\"', lang='en')) def test_util_from_n3_expectliteralwithtrailingbackslash(self): s = '"trailing\\\\"^^<http://www.w3.org/2001/XMLSchema#string>' res = util.from_n3(s) - self.assert_(res, Literal('trailing\\', datatype=XSD['string'])) - self.assert_(res.n3(), s) + self.assertTrue(res, Literal('trailing\\', datatype=XSD['string'])) + self.assertTrue(res.n3(), s) def test_util_from_n3_expectpartialidempotencewithn3(self): for n3 in ('<http://ex.com/foo>', @@ -263,7 +263,7 @@ class TestUtilTermConvert(unittest.TestCase): '"\\""@en', '"""multi\n"line"\nstring"""@en'): res, exp = util.from_n3(n3), parse_n3(n3) - self.assertEquals(res, exp, + self.assertEqual(res, exp, 'from_n3(%(n3e)r): %(res)r != parser.notation3: %(exp)r' % { 'res': res, 'exp': exp, 'n3e':n3}) @@ -272,12 +272,12 @@ class TestUtilTermConvert(unittest.TestCase): def test_util_from_n3_expectquotedgraph(self): s = '{<http://example.com/schema>}' res = util.from_n3(s, default=None, backend="IOMemory") - self.assert_(isinstance(res, QuotedGraph)) + self.assertTrue(isinstance(res, QuotedGraph)) def test_util_from_n3_expectgraph(self): s = '[<http://example.com/schema>]' res = util.from_n3(s, default=None, backend="IOMemory") - self.assert_(isinstance(res, Graph)) + self.assertTrue(isinstance(res, Graph)) class TestUtilCheckers(unittest.TestCase): def setUp(self): @@ -295,19 +295,19 @@ class TestUtilCheckers(unittest.TestCase): def test_util_check_context(self): res = util.check_context(self.c) - self.assert_(res == None) + self.assertTrue(res == None) def test_util_check_subject(self): res = util.check_subject(self.s) - self.assert_(res == None) + self.assertTrue(res == None) def test_util_check_predicate(self): res = util.check_predicate(self.p) - self.assert_(res == None) + self.assertTrue(res == None) def test_util_check_object(self): res = util.check_object(self.o) - self.assert_(res == None) + self.assertTrue(res == None) def test_util_check_statement(self): c = "http://example.com" @@ -324,7 +324,7 @@ class TestUtilCheckers(unittest.TestCase): util.check_statement, (self.s, self.p, c)) res = util.check_statement((self.s, self.p, self.o)) - self.assert_(res == None) + self.assertTrue(res == None) def test_util_check_pattern(self): c = "http://example.com" @@ -341,7 +341,7 @@ class TestUtilCheckers(unittest.TestCase): util.check_pattern, (self.s, self.p, c)) res = util.check_pattern((self.s, self.p, self.o)) - self.assert_(res == None) + self.assertTrue(res == None) if __name__ == "__main__": unittest.main() |