autonomous-app 0.2.25__py3-none-any.whl → 0.3.1__py3-none-any.whl

autonomous/db/queryset/visitor.py

@@ -0,0 +1,189 @@
+import copy
+import warnings
+
+from autonomous.db.errors import InvalidQueryError
+from autonomous.db.queryset import transform
+
+__all__ = ("Q", "QNode")
+
+
+def warn_empty_is_deprecated():
+    msg = "'empty' property is deprecated in favour of using 'not bool(filter)'"
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+
+
+class QNodeVisitor:
+    """Base visitor class for visiting Q-object nodes in a query tree."""
+
+    def visit_combination(self, combination):
+        """Called by QCombination objects."""
+        return combination
+
+    def visit_query(self, query):
+        """Called by (New)Q objects."""
+        return query
+
+
+class DuplicateQueryConditionsError(InvalidQueryError):
+    pass
+
+
+class SimplificationVisitor(QNodeVisitor):
+    """Simplifies query trees by combining unnecessary 'and' connection nodes
+    into a single Q-object.
+    """
+
+    def visit_combination(self, combination):
+        if combination.operation == combination.AND:
+            # The simplification only applies to 'simple' queries
+            if all(isinstance(node, Q) for node in combination.children):
+                queries = [n.query for n in combination.children]
+                try:
+                    return Q(**self._query_conjunction(queries))
+                except DuplicateQueryConditionsError:
+                    # Cannot be simplified
+                    pass
+        return combination
+
+    def _query_conjunction(self, queries):
+        """Merges query dicts - effectively &ing them together."""
+        query_ops = set()
+        combined_query = {}
+        for query in queries:
+            ops = set(query.keys())
+            # Make sure that the same operation isn't applied more than once
+            # to a single field
+            intersection = ops.intersection(query_ops)
+            if intersection:
+                raise DuplicateQueryConditionsError()
+
+            query_ops.update(ops)
+            combined_query.update(copy.deepcopy(query))
+        return combined_query
+
+
+class QueryCompilerVisitor(QNodeVisitor):
+    """Compiles the nodes in a query tree to a PyMongo-compatible query
+    dictionary.
+    """
+
+    def __init__(self, document):
+        self.document = document
+
+    def visit_combination(self, combination):
+        operator = "$and"
+        if combination.operation == combination.OR:
+            operator = "$or"
+        return {operator: combination.children}
+
+    def visit_query(self, query):
+        return transform.query(self.document, **query.query)
+
+
+class QNode:
+    """Base class for nodes in query trees."""
+
+    AND = 0
+    OR = 1
+
+    def to_query(self, document):
+        query = self.accept(SimplificationVisitor())
+        query = query.accept(QueryCompilerVisitor(document))
+        return query
+
+    def accept(self, visitor):
+        raise NotImplementedError
+
+    def _combine(self, other, operation):
+        """Combine this node with another node into a QCombination
+        object.
+        """
+        # If the other Q() is empty, ignore it and just use `self`.
+        if not bool(other):
+            return self
+
+        # Or if this Q is empty, ignore it and just use `other`.
+        if not bool(self):
+            return other
+
+        return QCombination(operation, [self, other])
+
+    @property
+    def empty(self):
+        warn_empty_is_deprecated()
+        return False
+
+    def __or__(self, other):
+        return self._combine(other, self.OR)
+
+    def __and__(self, other):
+        return self._combine(other, self.AND)
+
+
+class QCombination(QNode):
+    """Represents the combination of several conditions by a given
+    logical operator.
+    """
+
+    def __init__(self, operation, children):
+        self.operation = operation
+        self.children = []
+        for node in children:
+            # If the child is a combination of the same type, we can merge its
+            # children directly into this combinations children
+            if isinstance(node, QCombination) and node.operation == operation:
+                self.children += node.children
+            else:
+                self.children.append(node)
+
+    def __repr__(self):
+        op = " & " if self.operation is self.AND else " | "
+        return "(%s)" % op.join([repr(node) for node in self.children])
+
+    def __bool__(self):
+        return bool(self.children)
+
+    def accept(self, visitor):
+        for i in range(len(self.children)):
+            if isinstance(self.children[i], QNode):
+                self.children[i] = self.children[i].accept(visitor)
+
+        return visitor.visit_combination(self)
+
+    @property
+    def empty(self):
+        warn_empty_is_deprecated()
+        return not bool(self.children)
+
+    def __eq__(self, other):
+        return (
+            self.__class__ == other.__class__
+            and self.operation == other.operation
+            and self.children == other.children
+        )
+
+
+class Q(QNode):
+    """A simple query object, used in a query tree to build up more complex
+    query structures.
+    """
+
+    def __init__(self, **query):
+        self.query = query
+
+    def __repr__(self):
+        return "Q(**%s)" % repr(self.query)
+
+    def __bool__(self):
+        return bool(self.query)
+
+    def __eq__(self, other):
+        return self.__class__ == other.__class__ and self.query == other.query
+
+    def accept(self, visitor):
+        return visitor.visit_query(self)
+
+    @property
+    def empty(self):
+        warn_empty_is_deprecated()
+        return not bool(self.query)

autonomous/db/signals.py

@@ -0,0 +1,59 @@
+__all__ = (
+    "pre_init",
+    "post_init",
+    "pre_save",
+    "pre_save_post_validation",
+    "post_save",
+    "pre_delete",
+    "post_delete",
+)
+
+signals_available = False
+try:
+    from blinker import Namespace
+
+    signals_available = True
+except ImportError:
+
+    class Namespace:
+        def signal(self, name, doc=None):
+            return _FakeSignal(name, doc)
+
+    class _FakeSignal:
+        """If blinker is unavailable, create a fake class with the same
+        interface that allows sending of signals but will fail with an
+        error on anything else.  Instead of doing anything on send, it
+        will just ignore the arguments and do nothing instead.
+        """
+
+        def __init__(self, name, doc=None):
+            self.name = name
+            self.__doc__ = doc
+
+        def _fail(self, *args, **kwargs):
+            raise RuntimeError(
+                "signalling support is unavailable "
+                "because the blinker library is "
+                "not installed."
+            )
+
+        send = lambda *a, **kw: None  # noqa
+        connect = disconnect = has_receivers_for = receivers_for = (
+            temporarily_connected_to
+        ) = _fail
+        del _fail
+
+
+# the namespace for code signals.  If you are not autonomous.db code, do
+# not put signals in here.  Create your own namespace instead.
+_signals = Namespace()
+
+pre_init = _signals.signal("pre_init")
+post_init = _signals.signal("post_init")
+pre_save = _signals.signal("pre_save")
+pre_save_post_validation = _signals.signal("pre_save_post_validation")
+post_save = _signals.signal("post_save")
+pre_delete = _signals.signal("pre_delete")
+post_delete = _signals.signal("post_delete")
+pre_bulk_insert = _signals.signal("pre_bulk_insert")
+post_bulk_insert = _signals.signal("post_bulk_insert")

autonomous/logger.py

@@ -43,6 +43,7 @@ class Logger:
 
     def __call__(self, *args, **kwargs):
         if self.enabled:
+            is_printed = kwargs.pop("_print", False)
             caller = inspect.stack()[1]
             fn = caller.filename.split("/")[-1]
             msg = f"\n\n{'='*20}\t{fn}:{caller.function}()::{caller.lineno}\t{'='*20}\n"
@@ -57,6 +58,8 @@ class Logger:
                 current.write(f"{msg}\n")
             with open(self.logarchive, "a") as archive:
                 archive.write(f"{msg}\n")
+            if is_printed:
+                print(msg)
 
 
 log = Logger()

autonomous/model/autoattr.py

@@ -0,0 +1,120 @@
+from autonomous import log
+from autonomous.db.fields import (
+    BooleanField,
+    DateTimeField,
+    DictField,
+    DoesNotExist,
+    EmailField,
+    EnumField,
+    FileField,
+    FloatField,
+    GenericLazyReferenceField,
+    GenericReferenceField,
+    ImageField,
+    IntField,
+    ListField,
+    StringField,
+)
+
+
+class StringAttr(StringField):
+    pass
+
+
+class IntAttr(IntField):
+    pass
+
+
+class FloatAttr(FloatField):
+    pass
+
+
+class BoolAttr(BooleanField):
+    pass
+
+
+class DateTimeAttr(DateTimeField):
+    pass
+
+
+class EmailAttr(EmailField):
+    pass
+
+
+class FileAttr(FileField):
+    pass
+
+
+class ImageAttr(ImageField):
+    pass
+
+
+class ReferenceAttr(GenericReferenceField):
+    def __get__(self, instance, owner):
+        try:
+            result = super().__get__(instance, owner)
+        except DoesNotExist as e:
+            log(f"ReferenceAttr Error: {e}")
+            return None
+        return result
+
+
+# class ReferenceAttr(GenericLazyReferenceField):
+#     def __get__(self, instance, owner):
+#         try:
+#             result = super().__get__(instance, owner)
+#         except DoesNotExist as e:
+#             log(f"ReferenceAttr Error: {e}")
+#             return None
+#         return result.fetch() if result and result.pk else result
+
+# except DoesNotExist:
+# If the document doesn't exist, return None
+#    return None
+
+# def validate(self, value):
+#     if value is not None and not self.required:
+#         super().validate(value)
+
+
+class ListAttr(ListField):
+    # pass
+    def __get__(self, instance, owner):
+        # log(instance, owner)
+        results = super().__get__(instance, owner) or []
+        # print(self.name, self.field, owner, results)
+        if isinstance(self.field, ReferenceAttr):
+            i = 0
+            while i < len(results):
+                try:
+                    if not results[i]:
+                        log(f"Removing Object: {results[i]}")
+                        results.pop(i)
+                    else:
+                        i += 1
+                except DoesNotExist:
+                    results.pop(i)
+                    log(f"Object Not Found: {results[i]}")
+        # log(results)
+        return results
+
+
+class DictAttr(DictField):
+    def __get__(self, instance, owner):
+        # log(instance, owner)
+        results = super().__get__(instance, owner) or {}
+        log(self.name, self.field, owner, results)
+        for key, lazy_obj in results.items():
+            try:
+                if hasattr(lazy_obj, "fetch"):
+                    lazy_obj = (
+                        lazy_obj.fetch() if lazy_obj and lazy_obj.pk else lazy_obj
+                    )
+            except DoesNotExist:
+                log(f"Object Not Found: {lazy_obj}")
+            results[key] = lazy_obj
+        return results
+
+
+class EnumAttr(EnumField):
+    pass