externalized some utils to splendid

Author: joernhees

gp_query.py

@@ -8,7 +8,6 @@
 from collections import defaultdict
 from collections import Counter
 from collections import Sequence
-
 import logging
 import re
 import socket
@@ -17,26 +16,24 @@
 from cachetools import LRUCache
 import six
 from rdflib.term import Identifier
-
-
 import SPARQLWrapper
 from SPARQLWrapper.SPARQLExceptions import EndPointNotFound
 from SPARQLWrapper.SPARQLExceptions import SPARQLWrapperException
 from xml.sax.expatreader import SAXParseException
 # noinspection PyUnresolvedReferences
 from six.moves.urllib.error import URLError
+from splendid import chunker
+from splendid import get_path
+from splendid import time_func
 
 import config
 from graph_pattern import GraphPattern
 from graph_pattern import SOURCE_VAR
 from graph_pattern import TARGET_VAR
 from graph_pattern import ASK_VAR
 from graph_pattern import COUNT_VAR
-from utils import chunker
 from utils import exception_stack_catcher
-from utils import get_path
 from utils import sparql_json_result_bindings_to_rdflib
-from utils import time
 from utils import timer
 
 logger = logging.getLogger(__name__)
@@ -63,7 +60,7 @@ def calibrate_query_timeout(
         sparql.resetQuery()
         sparql.setReturnFormat(SPARQLWrapper.JSON)
         sparql.setQuery(q)
-        t, r = time(sparql.queryAndConvert)
+        t, r = time_func(sparql.queryAndConvert)
         total_time += t
     avg = total_time / n_queries
     timeout = avg * factor
@@ -392,7 +389,7 @@ def _query(
         try:
             q_short = ' '.join((line.strip() for line in q.split('\n')))
             sparql.setQuery(q_short)
-            c = time(sparql.queryAndConvert)
+            c = time_func(sparql.queryAndConvert)
         except socket.timeout:
             c = (timeout, {})
         except ValueError:

prediction_baselines.py

@@ -9,14 +9,14 @@
 from rdflib import URIRef
 from rdflib import Literal
 from rdflib import Variable
+from splendid import get_path
 
 import config
 from gp_learner import find_in_prediction
 from graph_pattern import TARGET_VAR
 from ground_truth_tools import get_semantic_associations
 from ground_truth_tools import split_training_test_set
 import gp_query
-from utils import get_path
 from utils import sparql_json_result_bindings_to_rdflib
 
 TIMEOUT = 30

requirements.txt

@@ -13,6 +13,7 @@ scipy>=0.18.1
 scoop>=0.7.1.1
 six>=1.10.0
 SPARQLWrapper>=1.7.6
+splendid>=1.0.2
 
 # cachetools==2.0.0
 # click==6.6

serialization.py

@@ -22,12 +22,12 @@
 import deap.base
 import deap.tools
 import numpy as np
+from splendid import run_once
 
 import config
 from graph_pattern import GraphPattern
 from gtp_scores import GTPScores
 from utils import decurify
-from utils import run_once
 
 logger = logging.getLogger(__name__)
 

utils.py

@@ -23,20 +23,6 @@
 import six
 
 
-def chunker(iterable, n, fillvalue=None):
-    """Like a grouper but last tuple is shorter.
-
-    >>> list(chunker([1, 2, 3, 4, 5], 3))
-    [[1, 2, 3], [4, 5]]
-    """
-    if n < 1:
-        raise ValueError("can't chunk by n=%d" % n)
-    args = [iter(iterable)] * n
-    return (
-        [e for e in t if e is not None]
-        for t in izip_longest(*args, fillvalue=fillvalue)
-    )
-
 # TODO: maybe automagically get these from http://prefix.cc ?
 # TODO: make this configurable
 _nsm = NamespaceManager(rdflib.Graph())
@@ -216,44 +202,6 @@ def inner(*args, **kwds):
     return outer
 
 
-def get_path(nested, key_path, default=None):
-    """Walks given nested by key_path returning default on any LookupError.
-
-    :param nested: a nested dictionary or list like structure
-    :param key_path: a list resembling a nested path of keys
-    :param default: returned if any key in the path isn't found
-    :return: value of nested[k0][k1]...[kn] or default on error
-
-    >>> get_path({'foo':[{'bar':3}]}, ['foo'], 'not found')
-    [{'bar': 3}]
-    >>> get_path({'foo':[{'bar':3}]}, ['foo', 'bar'], 'not found')
-    'not found'
-    >>> get_path({'foo':[{'bar':3}]}, ['foo', 0, 'bar'], 'not found')
-    3
-    >>> get_path({'foo':[{'bar':3}]}, ['foo', 0], 'not found')
-    {'bar': 3}
-    """
-    while len(key_path) > 0:
-        key, rest = key_path[0], key_path[1:]
-        try:
-            nested = nested[key]
-        except (LookupError, TypeError):
-            return default
-        key_path = rest
-    return nested
-
-
-def run_once(func):
-    """Decorator that causes a function to be executed only once."""
-    @wraps(func)
-    def wrapper(*args, **kwds):
-        if not wrapper.ran:
-            wrapper.ran = True
-            return func(*args, **kwds)
-    wrapper.ran = False
-    return wrapper
-
-
 def sample_from_list(l, probs, max_n=None):
     """Sample list according to probs.
 
@@ -340,18 +288,3 @@ def dict_to_rdflib(d):
         res_bindings_rdflib.append(tmp)
 
     return res_bindings_rdflib
-
-
-
-def time(func, *args, **kwds):
-    """Evaluates function with given args and returns
-
-    :param func: function to be evaluated
-    :param args: args for func
-    :param kwds: kwds for func
-    :return: a tuple: (timediff, func(*args, **kwds)
-    """
-    start = timer()
-    res = func(*args, **kwds)
-    stop = timer()
-    return stop - start, res