django-restit 4.0.12__py3-none-any.whl → 4.1.1__py3-none-any.whl

rest/{models.py → models/base.py}

@@ -1,381 +1,28 @@
-import os
-from django.conf import settings
-from django.core.exceptions import FieldDoesNotExist
-from hashids import Hashids
-import hashlib
-import string
-from io import StringIO
-
 from datetime import datetime, date, timedelta
 from decimal import Decimal
-TWOPLACES = Decimal(10) ** -2
+from objict import objict
+import importlib
 
-from django.db import models
-from django.apps import apps
+from django.db import models as dm
 from django.db.transaction import atomic
-get_model = apps.get_model
-
-from django.http import Http404
-from django.core.exceptions import ValidationError
-
-import threading
+from django.apps import apps
 
-from rest import helpers as rest_helpers
-from rest.uberdict import UberDict
-from rest import search
+from rest import helpers as rh
+from rest import errors as re
 from rest.encryption import ENCRYPTER, DECRYPTER
+from rest import crypto
+from rest import settings
+from rest import search
+from .metadata import MetaDataBase, MetaDataModel
 
-import importlib
+DB_ROUTING_MAPS = settings.get("DB_ROUTING_MAPS", {})
+TWO_DECIMAL_PLACES = Decimal(10) ** -2
 
-GRAPH_HELPERS = UberDict()
+GRAPH_HELPERS = objict()
 GRAPH_HELPERS.restGet = None
 GRAPH_HELPERS.get_request = None
 GRAPH_HELPERS.views = None
 
-NOTFOUND = "311!@#$%^&*"
-
-DB_ROUTING_MAPS = getattr(settings, "DB_ROUTING_MAPS", {})
-
-
-class RestError(Exception):
-    def __init__(self, reason, code=None):
-        self.reason = reason
-        self.code = code
-
-    def __repr__(self):
-        return self.reason
-
-
-class PermissionDeniedException(RestError):
-    def __init__(self, reason="permission denied", code=401):
-        self.reason = reason
-        self.code = code
-
-
-class RestValidationError(RestError):
-    def __init__(self, reason="rest data is not valid", code=123):
-        self.reason = reason
-        self.code = code
-
-
-def requestHasPerms(request, perms, group=None):
-    # third party auth models
-    if request.auth_model is not None:
-        if request.auth_model.hasPerm(perms):
-            return True, None, None
-
-    if not request.user.is_authenticated:
-        return False, "auth required", 401
-
-    if request.member.hasPerm(perms):
-        return True, None, None
-    if group is None and hasattr(request, "group"):
-        group = request.group
-    ms_perms = None
-    if group:
-        ms = request.member.getMembershipFor(group)
-        if ms and ms.hasPerm(perms):
-            return True, None, None
-        if ms:
-            ms_perms = ms.getPermissions()
-
-    # rest_helpers.log_error(F"PERMISSION DENIED for {request.member.username}, {perms}", str(group), ms_perms)
-    return False, "permission denied", 402
-
-
-class MetaDataBase(models.Model):
-    class Meta:
-        abstract = True
-
-    category = models.CharField(db_index=True, max_length=32, default=None, null=True, blank=True)
-
-    key = models.CharField(db_index=True, max_length=80)
-
-    value_format = models.CharField(max_length=16)
-    value = models.TextField()
-
-    int_value = models.IntegerField(default=None, null=True, blank=True)
-    float_value = models.IntegerField(default=None, null=True, blank=True)
-
-    def setValue(self, value):
-        self.value = "{}".format(value)
-        if type(value) is int or self.value in ["0", "1"]:
-            if type(value) is int and value > 2147483647:
-                self.value_format = "S"
-                return
-            self.value_format = "I"
-            self.int_value = value
-        elif type(value) is float:
-            self.value_format = "F"
-            self.float_value = value
-        elif isinstance(value, list):
-            self.value_format = "L"
-            # self.value = ",".join(value)
-        elif isinstance(value, dict):
-            self.value_format = "O"
-        elif type(value) in [str, str] and len(value) < 9 and value.isdigit():
-            self.value_format = "I"
-            self.int_value = value
-        elif value in ["True", "true", "False", "false"]:
-            self.value_format = "I"
-            if value in ["True", "true"]:
-                self.int_value = 1
-            else:
-                self.int_value = 0
-        elif isinstance(value, bool):
-            self.value_format = "I"
-            if value:
-                self.int_value = 1
-            else:
-                self.int_value = 0
-        else:
-            self.value_format = "S"
-
-    def getStrictType(self, field_type):
-        if type(self.value) is field_type:
-            return self.value
-        if field_type in [int, str, float, str]:
-            return field_type(self.value)
-        elif field_type is bool:
-            if self.value_format == 'I':
-                return self.int_value != 0
-            return self.value in [True, 1, '1', 'y', 'Y', 'Yes', 'true', 'True']
-        elif field_type in [date, datetime]:
-            return rest_helpers.parseDate(self.value)
-        return self.value
-
-    def getValue(self, field_type=None):
-        if field_type:
-            return self.getStrictType(field_type)
-        elif self.value_format == 'I':
-            return self.int_value
-        elif self.value_format == 'F':
-            return self.float_value
-        elif self.value_format in ["L", "O"] and self.value:
-            try:
-                return eval(self.value)
-            except Exception:
-                pass
-        return self.value
-
-    def __unicode__(self):
-        if self.category:
-            return "{}.{}={}".format(self.category, self.key, self.value)
-        return "{}={}".format(self.key, self.value)
-
-    def __str__(self):
-        if self.category:
-            return "{}.{}={}".format(self.category, self.key, self.value)
-        return "{}={}".format(self.key, self.value)
-
-
-class MetaDataModel(object):
-    def set_metadata(self, request, values=None):
-        # this may get called before the model is saved
-        if not self.id:
-            self.save()
-
-        if values is None:
-            values = request
-            request = None
-
-        if not isinstance(values, dict):
-            raise Exception("invalid metadata: {}".format(values))
-
-        for key, value in list(values.items()):
-            cat = None
-            if "." in key:
-                cat, key = key.split('.')
-            self.setProperty(key, value, cat, request=request)
-
-    def metadata(self):
-        return self.getProperties()
-
-    def removeProperties(self, category=None):
-        # this will remove all properties
-        # if category is not it will remove all properties
-        self.properties.filter(category=category).delete()
-
-    def getProperties(self, category=None):
-        ret = {}
-        for p in self.properties.all():
-            if p.category:
-                props = self.getFieldProps(p.category)
-                if props.hidden:
-                    continue
-                if p.category not in ret or not isinstance(ret.get(p.category, None), dict):
-                    ret[p.category] = {}
-                props = self.getFieldProps("{}.{}".format(p.category, p.key))
-                if props.hidden:
-                    continue
-                ret[p.category][p.key] = p.getValue()
-            else:
-                props = self.getFieldProps(p.key)
-                if props.hidden:
-                    continue
-                ret[p.key] = p.getValue()
-        if category is not None:
-            if category in ret:
-                return ret[category]
-            return {}
-        return ret
-
-    def __initFieldProps(self):
-        if not hasattr(self, "__field_props"):
-            if hasattr(self.RestMeta, "METADATA_FIELD_PROPERTIES"):
-                # this provides extra protection for metadata fields
-                self.__field_props = self.RestMeta.METADATA_FIELD_PROPERTIES
-            else:
-                self.__field_props = None
-
-    def getFieldProps(self, key):
-        self.__initFieldProps()
-        full_key = key
-        category = None
-        if "." in key:
-            category, key = key.split('.')
-        props = UberDict()
-        if self.__field_props:
-            if category and self.__field_props.get(category, None):
-                cat_props = self.__field_props.get(category, None)
-                if cat_props:
-                    props.notify = cat_props.get("notify", None)
-                    props.requires = cat_props.get("requires", None)
-                    props.on_change_name = cat_props.get("on_change", None)
-                    props.hidden = cat_props.get("hidden", False)
-                    if props.on_change_name:
-                        props.on_change = getattr(self, props.on_change_name, None)
-            field_props = self.__field_props.get(full_key, None)
-            if field_props:
-                props.notify = field_props.get("notify", props.notify)
-                props.requires = field_props.get("requires", None)
-                props.hidden = field_props.get("hidden", False)
-                on_change_name = field_props.get("on_change", None)
-                if on_change_name:
-                    on_change = getattr(self, on_change_name, None)
-                    if on_change:
-                        props.on_change = on_change
-        return props
-
-    def checkFieldPerms(self, full_key, props, request=None):
-        if not props.requires:
-            return True
-        if not request or not request.member:
-            return False
-        if request.member.hasPermission(props.requires) or request.user.is_superuser:
-            return True
-
-        # this a unauthorized attempt to change field, log and throw exception
-        if props.notify and request.member:
-            subject = "permission denied changing protected '{}' field".format(full_key)
-            msg = "permission denied changing protected field '{}'\nby user: {}\nfor: {}".format(
-                    full_key,
-                    request.user.username,
-                    self
-                )
-            request.member.notifyWithPermission(props.notify, subject, msg, email_only=True)
-        raise PermissionDeniedException(subject)
-
-    def setProperties(self, data, category=None, request=None, using=None):
-        for k, v in data.items():
-            self.setProperty(k, v, category, request=request, using=using)
-
-    def setProperty(self, key, value, category=None, request=None, using=None, ascii_only=False, encrypted=False):
-        # rest_helpers.log_print("{}:{} ({})".format(key, value, type(value)))
-        if ascii_only and isinstance(value, str):
-            value = "".join([x for x in value if x in string.printable])
-        if encrypted:
-            value = ENCRYPTER.encrypt(value)
-        on_change = None
-        if not using:
-            using = getattr(self.RestMeta, "DATABASE", using)
-        if not request:
-            request = RestModel.getActiveRequest()
-        self.__initFieldProps()
-
-        if isinstance(value, dict):
-            return self.setProperties(value, key)
-        username = "root"
-        if request and request.member:
-            username = request.member.username
-        prop = None
-
-        if "." in key:
-            category, key = key.split('.')
-        if category:
-            # delete any keys with this category name
-            full_key = "{}.{}".format(category, key)
-            # this deletes anything with the key that matches the category
-            # this works because the category is stored not in key but category field
-            # rest_helpers.log_print("deleting key={}".format(category))
-            self.properties.filter(key=category).delete()
-        else:
-            full_key = key
-
-        field_props = self.getFieldProps(full_key)
-        if not self.checkFieldPerms(full_key, field_props, request):
-            return False
-
-        check_value = "{}".format(value)
-        has_changed = False
-        prop = self.properties.filter(category=category, key=key).last()
-        old_value = None
-        if prop:
-            # existing property we need to make sure we delete
-            old_value = prop.getValue()
-            if value is None or value == "":
-                prop.delete()
-                has_changed = True
-            else:
-                has_changed = check_value != prop.value
-                if not has_changed:
-                    return
-                prop.setValue(value)
-                prop.save(using=using)
-            if field_props.on_change:
-                field_props.on_change(key, value, old_value, category)
-        elif value is None or value == "":
-            # do not create none or empty property
-            return False
-        else:
-            has_changed = True
-            PropClass = self.get_fk_model("properties")
-            prop = PropClass(parent=self, key=key, category=category)
-            prop.setValue(value)
-            # rest_helpers.log_print(u"saving {}.{}".format(category, key))
-            # rest_helpers.log_print(u"saving {} : {}".format(full_key, value))
-            prop.save(using=using)
-
-        if hasattr(self, "_recordRestChange"):
-            self._recordRestChange("metadata.{}".format(full_key), old_value)
-
-        if field_props.notify and request and request.member:
-            notify = field_props.get("notify")
-            if value:
-                value = str(value)
-                if len(value) > 5:
-                    value = "***"
-            msg = "protected field '{}' changed to '{}'\nby user: {}\nfor: {}".format(
-                full_key,
-                value,
-                username,
-                self
-            )
-            request.member.notifyWithPermission(notify, "protected '{}' field changed".format(full_key), msg, email_only=True)
-        return has_changed
-
-    def getProperty(self, key, default=None, category=None, field_type=None, decrypted=False):
-        try:
-            if "." in key:
-                category, key = key.split('.')
-            value = self.properties.get(category=category, key=key).getValue(field_type)
-            if decrypted and value is not None:
-                return DECRYPTER.decrypt(value)
-            return value
-        except Exception:
-            pass
-        return default
-
 
 class RestModel(object):
     class __RestMeta__:
@@ -390,23 +37,7 @@ class RestModel(object):
 
     @staticmethod
     def generateUUID(*args, **kwargs):
-        upper = kwargs.get("upper", True)
-        max_length = kwargs.get("max_length", None)
-        uuid = ""
-        for key in args:
-            if isinstance(key, float):
-                key = str(float)
-            if isinstance(key, int):
-                uuid += Hashids().encrypt(key)
-            if isinstance(key, str):
-                uuid += rest_helpers.toString(hashlib.md5(rest_helpers.toBytes(key)).hexdigest())
-        if len(uuid) > 125:
-            uuid = uuid[:125]
-        if max_length != None:
-            uuid = uuid[:max_length]
-        if upper:
-            return uuid.upper()
-        return uuid
+        return crypto.generateUUID(*args, **kwargs)
 
     @classmethod
     def buildGraph(cls, name):
@@ -457,8 +88,6 @@ class RestModel(object):
                         continue
 
                 if isinstance(gname, dict):
-                    size = gname.get("size")
-                    sort = gname.get("sort")
                     fm_name = gname.get("model")
                     gname = gname.get("graph")
                     if not gname:
@@ -482,7 +111,7 @@ class RestModel(object):
                 if not ForeignModel:
                     ForeignModel = cls.get_fk_model(field)
                 if not ForeignModel:
-                    rest_helpers.log_print("no foreignkey: {0}".format(field))
+                    rh.log_print("no foreignkey: {0}".format(field))
                     continue
 
                 if field not in graph["recurse_into"]:
@@ -591,7 +220,7 @@ class RestModel(object):
 
     @classmethod
     def getActiveLogger(cls):
-        return rest_helpers.getLogger(cls.getActiveRequest())
+        return rh.getLogger(cls.getActiveRequest())
 
     @classmethod
     def getActiveMember(cls):
@@ -602,10 +231,7 @@ class RestModel(object):
 
     @classmethod
     def getActiveRequest(cls):
-        if not GRAPH_HELPERS.get_request:
-            mw = importlib.import_module("rest.middleware")
-            GRAPH_HELPERS.get_request = mw.get_request
-        return GRAPH_HELPERS.get_request()
+        return rh.getActiveRequest()
 
     @classmethod
     def getFromRequest(cls, request):
@@ -661,7 +287,7 @@ class RestModel(object):
         # called by the rest module to magically parse
         # a component that is marked genericr elation in a graph
         if not hasattr(self, field):
-            rest_helpers.log_print("model has no field: {0}".format(field))
+            rh.log_print("model has no field: {0}".format(field))
             return None
 
         name = getattr(self, field)
@@ -670,7 +296,7 @@ class RestModel(object):
         a_name, m_name = name.split(".")
         model = RestModel.getModel(a_name, m_name)
         if not model:
-            rest_helpers.log_print("GENERIC MODEL DOES NOT EXIST: {0}".format(name))
+            rh.log_print("GENERIC MODEL DOES NOT EXIST: {0}".format(name))
         return model
 
     def restGetGenericRelation(self, field):
@@ -704,7 +330,7 @@ class RestModel(object):
         """
         Helper method to save a list of fields
         """
-        self._changed__ = UberDict()
+        self._changed__ = objict()
         for key, value in list(kwargs.items()):
             if value is None and not allow_null:
                 continue
@@ -714,7 +340,7 @@ class RestModel(object):
 
     def restSaveField(self, fieldname, value, has_fields=False, has_no_fields=False, using=None):
         if not hasattr(self, "_changed__"):
-            self._changed__ = UberDict()
+            self._changed__ = objict()
 
         if fieldname.startswith("_"):
             return
@@ -728,7 +354,7 @@ class RestModel(object):
         if has_fields and fieldname not in self.RestMeta.SAVE_FIELDS:
             return
         if fieldname.endswith("_id") and not self.get_field_type(fieldname):
-            # django will have ForeignKeys with _id, we don't want that, on_delete=models.CASCADE
+            # django will have ForeignKeys with _id, we don't want that, on_delete=dm.CASCADE
             fieldname = fieldname[:-3]
         setter = F"set_{fieldname}"
         if hasattr(self, setter):
@@ -737,7 +363,7 @@ class RestModel(object):
 
         if fieldname in self._field_names__:
             # TODO check if it is a function
-            if isinstance(value, models.Model):
+            if isinstance(value, dm.Model):
                 setattr(self, fieldname, value)
                 self._changed__[fieldname] = True
                 return
@@ -749,8 +375,8 @@ class RestModel(object):
                 if using is None:
                     using = self.restGetModelDB()
                 obj.saveFromDict(None, value, using=using)
-                # rest_helpers.log_print("{} vs {}".format(self._state.db, obj._state.db))
-                # rest_helpers.log_print("saving FK to {} ({}.{}) - {}".format(fieldname, using, obj.pk, type(obj)), value)
+                # rh.log_print("{} vs {}".format(self._state.db, obj._state.db))
+                # rh.log_print("saving FK to {} ({}.{}) - {}".format(fieldname, using, obj.pk, type(obj)), value)
                 setattr(self, fieldname, obj)
                 self._changed__[fieldname] = True
                 return
@@ -780,16 +406,16 @@ class RestModel(object):
                     if field_model and value != None:
                         field_model_name = field_model.__class__.__name__
                         if field_model_name == "DateTimeField":
-                            value = rest_helpers.parseDateTime(value)
+                            value = rh.parseDateTime(value)
                             # value = datetime.fromtimestamp(float(value))
                         elif field_model_name == "DateField":
-                            value = rest_helpers.parseDate(value, as_date=True)
+                            value = rh.parseDate(value, as_date=True)
                         elif field_model_name == "IntegerField":
                             value = int(value)
                         elif field_model_name == "FloatField":
                             value = float(value)
                         elif field_model_name == "CurrencyField":
-                            value = Decimal(value).quantize(TWOPLACES)
+                            value = Decimal(value).quantize(TWO_DECIMAL_PLACES)
                         elif field_model_name == "BooleanField":
                             if value in [True, 1, 'True', 'true', '1', 't', 'y', 'yes']:
                                 value = True
@@ -810,13 +436,13 @@ class RestModel(object):
 
     def _recordRestChange(self, fieldname, old_value):
         if not hasattr(self, "_changed__"):
-            self._changed__ = UberDict()
+            self._changed__ = objict()
         if "." in fieldname:
             fields = fieldname.split('.')
             root = self._changed__
             for f in fields[:-1]:
                 if f not in root:
-                    root[f] = UberDict()
+                    root[f] = objict()
                 root = root[f]
             root[fields[-1]] = old_value
         else:
@@ -831,7 +457,7 @@ class RestModel(object):
         if request is None:
             request = RestModel.getActiveRequest()
             if request is None:
-                request = UberDict(member=None, FILES=[], DATA=UberDict(), is_authenticated=False, is_local=True)
+                request = objict(member=None, FILES=[], DATA=objict(), is_authenticated=False, is_local=True)
         self.onRestCanSave(request)
         is_new = self.id is None
         has_fields = hasattr(self.RestMeta, "SAVE_FIELDS") and len(self.RestMeta.SAVE_FIELDS)
@@ -841,9 +467,9 @@ class RestModel(object):
         self._state.db = kwargs.get("using", self.restGetModelDB("default"))
         auto_save_fields = getattr(self.RestMeta, "AUTO_SAVE", None)
         if auto_save_fields:
-            # rest_helpers.log_print(auto_save_fields)
+            # rh.log_print(auto_save_fields)
             for field in auto_save_fields:
-                # rest_helpers.log_print(field)
+                # rh.log_print(field)
                 if isinstance(field, tuple):
                     m_field, req_field = field
                 else:
@@ -852,8 +478,8 @@ class RestModel(object):
                 req_value = getattr(request, req_field, None)
                 if request and req_value:
                     data[m_field] = req_value
-            # rest_helpers.log_print(data)
-        self._changed__ = UberDict()
+            # rh.log_print(data)
+        self._changed__ = objict()
         if hasattr(self.RestMeta, "POST_SAVE_FIELDS"):
             post_save_fields = self.RestMeta.POST_SAVE_FIELDS
         else:
@@ -920,7 +546,7 @@ class RestModel(object):
             else:
                 ForeignModel = self.get_fk_model(name)
                 if ForeignModel and ForeignModel.__name__ == "MediaItem":
-                    # rest_helpers.log_print("saving media file: {}".format(name))
+                    # rh.log_print("saving media file: {}".format(name))
                     self.saveMediaFile(files[name], name)
                 else:
                     remaining_files[name] = files[name]
@@ -929,7 +555,7 @@ class RestModel(object):
     def restSaveMediaFiles(self, files=None):
         MediaItemRef = RestModel.getModel("medialib", "MediaItemRef")
         component = self.get_class_name(True)
-        # rest_helpers.log_print("saving media files refs: {}".format(component))
+        # rh.log_print("saving media files refs: {}".format(component))
         for name in files:
             mi = self.saveMediaFile(files[name], name, is_local=False)
             mr = None
@@ -937,7 +563,7 @@ class RestModel(object):
                 # use existing reference
                 mr = MediaItemRef.objects.filter(component=component, component_id=self.id, media__name=name).last()
                 if mr:
-                    rest_helpers.log_print(F"existing media files refs: {name}.{component}.{self.id}")
+                    rh.log_print(F"existing media files refs: {name}.{component}.{self.id}")
                     mr.media = mi
                     mr.save()
             if mr is None:
@@ -979,13 +605,13 @@ class RestModel(object):
                     if field_model_name == "DateTimeField":
                         value = datetime.fromtimestamp(float(value))
                     elif field_model_name == "DateField":
-                        value = rest_helpers.parseDate(value)
+                        value = rh.parseDate(value)
                     elif field_model_name == "IntegerField":
                         value = int(value)
                     elif field_model_name == "FloatField":
                         value = float(value)
                     elif field_model_name == "CurrencyField":
-                        value = Decimal(value).quantize(TWOPLACES)
+                        value = Decimal(value).quantize(TWO_DECIMAL_PLACES)
                 if hasattr(self, key) and getattr(self, key) != value:
                     deltas.append(key)
             except:
@@ -1017,7 +643,7 @@ class RestModel(object):
                 mi = MediaItem(name=file_name, group=group, newfile=file)
         else:
             mi = MediaItem(name=file_name, newfile=file, group=group)
-        # rest_helpers.log_print(F"saving media file: {name}")
+        # rh.log_print(F"saving media file: {name}")
         mi.save()
         if is_local:
             setattr(self, name, mi)
@@ -1027,7 +653,7 @@ class RestModel(object):
         if not request:
             request = self.getActiveRequest()
         if not request or not hasattr(request, "setLogModel"):
-            rest_helpers.log_print("request does not support setLogModel")
+            rh.log_print("request does not support setLogModel")
             return
         if not self.id:
             self.save()
@@ -1049,9 +675,9 @@ class RestModel(object):
                 return True
             # we need to check if this user has permission
             group_field = getattr(self.RestMeta, "GROUP_FIELD", "group")
-            status, error, code = requestHasPerms(request, perms, getattr(self, group_field, None))
+            status, error, code = rh.requestHasPerms(request, perms, getattr(self, group_field, None))
             if not status:
-                raise PermissionDeniedException(error, code)
+                raise re.PermissionDeniedException(error, code)
         return True
 
     def on_rest_get(self, request):
@@ -1079,7 +705,7 @@ class RestModel(object):
                 return True
             # we need to check if this user has permission
             group_field = getattr(self.RestMeta, "GROUP_FIELD", "group")
-            # rest_helpers.log_error(F"group field={group_field}")
+            # rh.log_error(F"group field={group_field}")
             if self.pk is None:
                 group = request.DATA.get(group_field)
             elif "__" in group_field and hasattr(self, "group"):
@@ -1093,12 +719,12 @@ class RestModel(object):
                         break
             else:
                 group = getattr(self, group_field, None)
-            status, error, code = requestHasPerms(request, perms, group)
+            status, error, code = rh.requestHasPerms(request, perms, group)
             if not status:
                 if self.pk is None and code == 402:
                     code = 435
-                rest_helpers.log_error(F"onRestCheckSavePerms: {request.member} {group} permission denied: status={status}, error={error}, code={code}", perms)
-                raise PermissionDeniedException(error, code)
+                rh.log_error(F"onRestCheckSavePerms: {request.member} {group} permission denied: status={status}, error={error}, code={code}", perms)
+                raise re.PermissionDeniedException(error, code)
 
     def on_rest_post(self, request):
         self.saveFromRequest(request)
@@ -1198,7 +824,7 @@ class RestModel(object):
         member_field = getattr(cls.RestMeta, "VIEW_PERMS_MEMBER_FIELD", None)
         if member_field is None:
             return cls.objects.none()
-        # rest_helpers.log_error(dict(**{member_field: request.member}))
+        # rh.log_error(dict(**{member_field: request.member}))
         return qset.filter(**{member_field: request.member})
 
     @classmethod
@@ -1231,7 +857,7 @@ class RestModel(object):
 
     @classmethod
     def on_rest_filter_children(cls, request, qset=None):
-        # rest_helpers.log_error("filter by group?")
+        # rh.log_error("filter by group?")
         group_field = getattr(cls.RestMeta, "GROUP_FIELD", "group")
         if group_field is None or ("__" not in group_field and not cls.has_model_field_name(group_field)):
             return qset
@@ -1251,14 +877,14 @@ class RestModel(object):
             q = {}
             q[group_field] = request.group.id
             qset = qset.filter(**q)
-            # rest_helpers.log_error(q, qset.count())
+            # rh.log_error(q, qset.count())
         return qset
 
     @classmethod
     def on_rest_list_ready(cls, request, qset=None):
         # override on do any post filters
-        # rest_helpers.log_error("RAW SQL")
-        # rest_helpers.log_error(qset.query)
+        # rh.log_error("RAW SQL")
+        # rh.log_error(qset.query)
         return qset
 
     @classmethod
@@ -1276,7 +902,7 @@ class RestModel(object):
             if dr_tz is not None:
                 dr_eod = request.DATA.get("dr_eod", 0, field_type=int)
                 dr_granularity = request.DATA.get("granularity", "day")
-                dr_start, dr_end = rest_helpers.getDateRangeZ(dr_start, dr_end, dr_granularity, dr_tz, hour=dr_eod)
+                dr_start, dr_end = rh.getDateRangeZ(dr_start, dr_end, dr_granularity, dr_tz, hour=dr_eod)
             else:
                 dr_offset = request.DATA.get("dr_offset", 0, field_type=int)
                 if dr_offset > 0:
@@ -1288,8 +914,8 @@ class RestModel(object):
             q["{}__lte".format(dr_field)] = dr_end
             qset = qset.filter(**q)
             request.response_extra = dict(
-                dr_start=rest_helpers.convertToEpoch(dr_start),
-                dr_end=rest_helpers.convertToEpoch(dr_end))
+                dr_start=rh.convertToEpoch(dr_start),
+                dr_end=rh.convertToEpoch(dr_end))
         return qset
 
     @classmethod
@@ -1343,7 +969,7 @@ class RestModel(object):
         if format in ["summary", "summary_only"]:
             return cls.on_rest_list_summary(request, qset)
         if hasattr(cls.RestMeta, "FORMATS"):
-            fields =  cls.RestMeta.FORMATS.get(format)
+            fields = cls.RestMeta.FORMATS.get(format)
         else:
             no_show_fields = RestModel.__RestMeta__.NO_SHOW_FIELDS
             if hasattr(cls.RestMeta, "NO_SHOW_FIELDS"):
@@ -1381,21 +1007,21 @@ class RestModel(object):
     def on_rest_list_summary(cls, request, qset):
         cls._boundRest()
         summary_info = getattr(cls.RestMeta, "SUMMARY_FIELDS", {})
-        output = UberDict()
+        output = objict()
         output.count = qset.count()
         for key, value in summary_info.items():
             if key == "sum":
-                res = rest_helpers.getSum(qset, *value)
+                res = rh.getSum(qset, *value)
                 if isinstance(res, dict):
                     output.update(res)
                 else:
                     output[value[0]] = res
             elif key == "avg":
                 for f in value:
-                    output["avg_{}".format(f)] = rest_helpers.getAverage(qset, f)
+                    output["avg_{}".format(f)] = rh.getAverage(qset, f)
             elif key == "max":
                 for f in value:
-                    output["max_{}".format(f)] = rest_helpers.getMax(qset, f)
+                    output["max_{}".format(f)] = rh.getMax(qset, f)
             elif isinstance(value, dict):
                 if "|" in key:
                     fields = key.split("|")
@@ -1413,11 +1039,11 @@ class RestModel(object):
                 if action == "count":
                     output[lbl] = act_qset.count()
                 elif action == "sum":
-                    output[lbl] = rest_helpers.getSum(act_qset, field)
+                    output[lbl] = rh.getSum(act_qset, field)
                 elif action == "avg":
-                    output[lbl] = rest_helpers.getAverage(act_qset, field)
+                    output[lbl] = rh.getAverage(act_qset, field)
                 elif action == "max":
-                    output[lbl] = rest_helpers.getMax(act_qset, field)
+                    output[lbl] = rh.getMax(act_qset, field)
         return GRAPH_HELPERS.restGet(request, output)
 
     @classmethod
@@ -1450,14 +1076,13 @@ class RestModel(object):
         elif action == "create":
             batch_data = request.DATA.getlist("batch_data", [])
             items = []
-            exist = []
             for item in batch_data:
                 try:
                     obj = cls.ro_objects().filter(**item).last()
                     if not obj:
                         obj.saveFromDict(request, item)
                     items.append(obj)
-                except:
+                except Exception:
                     pass
             return GRAPH_HELPERS.restList(request, items)
         return GRAPH_HELPERS.restStatus(request, False, error="not implemented")
@@ -1474,7 +1099,7 @@ class RestModel(object):
             for k, v in list(cls.RestMeta.KEY_TO_FIELD_MAP.items()):
                 if hasattr(request, k):
                     value = getattr(request, k)
-                    if value != None:
+                    if value is not None:
                         kv[v] = value
             obj = cls.createFromRequest(request, **kv)
         else:
@@ -1501,7 +1126,7 @@ class RestModel(object):
 
     @classmethod
     def get_rest_help(cls):
-        output = UberDict()
+        output = objict()
         if cls.__doc__:
             output.doc = cls.__doc__.rstrip()
         else:
@@ -1626,13 +1251,13 @@ class RestModel(object):
             default_filters = getattr(cls.RestMeta, "LIST_DEFAULT_FILTERS", None)
             if default_filters:
                 # make a copy so we can remove filters until the end
-                request.default_rest_filters = UberDict.fromdict(default_filters)
+                request.default_rest_filters = objict.fromdict(default_filters)
 
     @classmethod
     def filterFromRequest(cls, request, qset):
         '''returns None if not foreignkey, otherswise the relevant model'''
         filter = request.DATA.pop("filter")
-        # rest_helpers.debug("filterFromRequest")
+        # rh.debug("filterFromRequest")
         cls.on_rest_set_query_defaults(request)
         if not filter:
             return qset
@@ -1698,14 +1323,14 @@ class RestModel(object):
                     value = 0
                 if isinstance(value, str) and "(" in value and ")" in value:
                     # this is a special function call
-                    # rest_helpers.log_print(value)
+                    # rh.log_print(value)
                     if value.startswith("days("):
                         spos = value.find("(")+1
                         epos = value.find(")")
-                        # rest_helpers.log_print(int(value[spos:epos]))
+                        # rh.log_print(int(value[spos:epos]))
                         value = now + timedelta(days=int(value[spos:epos]))
-                        # rest_helpers.log_print(now)
-                        # rest_helpers.log_print(value)
+                        # rh.log_print(now)
+                        # rh.log_print(value)
                     elif value.startswith("hours("):
                         spos = value.find("(")+1
                         epos = value.find(")")
@@ -1723,9 +1348,9 @@ class RestModel(object):
                 if key.count('__') <= 4:
                     q[key] = value
             else:
-                rest_helpers.log_print("filterFromRequest: invalid field: {} or {}".format(name, key))
+                rh.log_print("filterFromRequest: invalid field: {} or {}".format(name, key))
         if q:
-            # rest_helpers.debug("filtering...", q)
+            # rh.debug("filtering...", q)
             qset = qset.filter(**q)
         return qset
 
@@ -1782,7 +1407,7 @@ class RestModel(object):
         query_keys = request.DATA.keys()
         special_keys = getattr(cls.RestMeta, "QUERY_FIELDS_SPECIAL", {})
         cls.on_rest_set_query_defaults(request)
-        # rest_helpers.debug("queryFromRequest.key", query_keys, special_keys, field_names)
+        # rh.debug("queryFromRequest.key", query_keys, special_keys, field_names)
         for key in query_keys:
             # remove the key from defaults
             if request.default_rest_filters:
@@ -1854,10 +1479,10 @@ class RestModel(object):
                 value = True
             ft = cls.get_field_type(fn)
             if ft == "DateTimeField":
-                value = rest_helpers.parseDateTime(value)
+                value = rh.parseDateTime(value)
             q[key] = value
         if bool(q):
-            # rest_helpers.debug("queryFromRequest", q, request.default_rest_filters)
+            # rh.debug("queryFromRequest", q, request.default_rest_filters)
             qset = qset.filter(**q)
         return qset
 
@@ -1922,5 +1547,5 @@ class RestModel(object):
         try:
             field = cls._meta.get_field(fieldname)
             return field.related_model
-        except:
+        except Exception:
             return None