Move generic utils from __init__.py to basic.py.

2 files changed, 88 insertions, 80 deletions

diff --git a/raven/utils/__init__.py b/raven/utils/__init__.py
index fd8a953..b4b22b8 100644
--- a/raven/utils/__init__.py
+++ b/raven/utils/__init__.py
@@ -7,51 +7,18 @@ raven.utils
 """
 from __future__ import absolute_import
 
-from raven.utils.compat import iteritems, string_types
 import logging
-import threading
-from functools import update_wrapper
 try:
     import pkg_resources
 except ImportError:
     pkg_resources = None  # NOQA
 import sys
 
-logger = logging.getLogger('raven.errors')
+from raven.utils.compat import iteritems, string_types
+from raven.utils.basic import merge_dicts, varmap, memoize, once
 
 
-def merge_dicts(*dicts):
-    out = {}
-    for d in dicts:
-        if not d:
-            continue
-
-        for k, v in iteritems(d):
-            out[k] = v
-    return out
-
-
-def varmap(func, var, context=None, name=None):
-    """
-    Executes ``func(key_name, value)`` on all values
-    recurisively discovering dict and list scoped
-    values.
-    """
-    if context is None:
-        context = {}
-    objid = id(var)
-    if objid in context:
-        return func(name, '<...>')
-    context[objid] = 1
-    if isinstance(var, (list, tuple)):
-        ret = [varmap(func, f, context, name) for f in var]
-    else:
-        ret = func(name, var)
-        if isinstance(ret, dict):
-            ret = dict((k, varmap(func, v, context, k))
-                       for k, v in iteritems(var))
-    del context[objid]
-    return ret
+logger = logging.getLogger('raven.errors')
 
 
 # We store a cache of module_name->version string to avoid
@@ -144,47 +111,3 @@ def get_auth_header(protocol, timestamp, client, api_key,
         header.append(('sentry_secret', api_secret))
 
     return 'Sentry %s' % ', '.join('%s=%s' % (k, v) for k, v in header)
-
-
-class memoize(object):
-    """
-    Memoize the result of a property call.
-
-    >>> class A(object):
-    >>>     @memoize
-    >>>     def func(self):
-    >>>         return 'foo'
-    """
-
-    def __init__(self, func):
-        self.__name__ = func.__name__
-        self.__module__ = func.__module__
-        self.__doc__ = func.__doc__
-        self.func = func
-
-    def __get__(self, obj, type=None):
-        if obj is None:
-            return self
-        d, n = vars(obj), self.__name__
-        if n not in d:
-            d[n] = self.func(obj)
-        return d[n]
-
-
-def once(func):
-    """Runs a thing once and once only."""
-    lock = threading.Lock()
-
-    def new_func(*args, **kwargs):
-        if new_func.called:
-            return
-        with lock:
-            if new_func.called:
-                return
-            rv = func(*args, **kwargs)
-            new_func.called = True
-            return rv
-
-    new_func = update_wrapper(new_func, func)
-    new_func.called = False
-    return new_func
diff --git a/raven/utils/basic.py b/raven/utils/basic.py
new file mode 100644
index 0000000..4a40e8e
--- /dev/null
+++ b/raven/utils/basic.py
@@ -0,0 +1,85 @@
+from __future__ import absolute_import
+
+from functools import update_wrapper
+import threading
+
+from raven.utils.compat import iteritems
+
+
+def merge_dicts(*dicts):
+    out = {}
+    for d in dicts:
+        if not d:
+            continue
+
+        for k, v in iteritems(d):
+            out[k] = v
+    return out
+
+
+def varmap(func, var, context=None, name=None):
+    """
+    Executes ``func(key_name, value)`` on all values
+    recurisively discovering dict and list scoped
+    values.
+    """
+    if context is None:
+        context = {}
+    objid = id(var)
+    if objid in context:
+        return func(name, '<...>')
+    context[objid] = 1
+
+    if isinstance(var, (list, tuple)):
+        ret = [varmap(func, f, context, name) for f in var]
+    else:
+        ret = func(name, var)
+        if isinstance(ret, dict):
+            ret = dict((k, varmap(func, v, context, k))
+                       for k, v in iteritems(var))
+    del context[objid]
+    return ret
+
+
+class memoize(object):
+    """
+    Memoize the result of a property call.
+
+    >>> class A(object):
+    >>>     @memoize
+    >>>     def func(self):
+    >>>         return 'foo'
+    """
+
+    def __init__(self, func):
+        self.__name__ = func.__name__
+        self.__module__ = func.__module__
+        self.__doc__ = func.__doc__
+        self.func = func
+
+    def __get__(self, obj, type=None):
+        if obj is None:
+            return self
+        d, n = vars(obj), self.__name__
+        if n not in d:
+            d[n] = self.func(obj)
+        return d[n]
+
+
+def once(func):
+    """Runs a thing once and once only."""
+    lock = threading.Lock()
+
+    def new_func(*args, **kwargs):
+        if new_func.called:
+            return
+        with lock:
+            if new_func.called:
+                return
+            rv = func(*args, **kwargs)
+            new_func.called = True
+            return rv
+
+    new_func = update_wrapper(new_func, func)
+    new_func.called = False
+    return new_func