Merge pull request #179 from aperture-data/release-0.3.6

Release 0.3.6

Author: gsaluja9

.github/workflows/checks.yml

@@ -12,7 +12,7 @@ jobs:
     - uses: actions/checkout@v2
     - uses: actions/setup-python@v3
       with:
-        python-version: '3.8.10'
+        python-version: '3.10'
     - uses: pre-commit/[email protected]
     - uses: actions/checkout@v2
     - uses: luisremis/find-trailing-whitespace@master

aperturedb/Blobs.py

@@ -1,23 +1,7 @@
 from __future__ import annotations
-from typing import Dict
 
-from aperturedb.Connector import Connector
 from aperturedb.Entities import Entities
-from aperturedb.Query import Query
 
 
 class Blobs(Entities):
     db_object = "_Blob"
-
-    @classmethod
-    def retrieve(cls,
-                 db: Connector,
-                 spec: Query,
-                 with_adjacent: Dict[str, Query] = None) -> Blobs:
-        spec.with_class = cls.db_object
-
-        results = Entities.retrieve(
-            db=db, spec=spec, with_adjacent=with_adjacent)
-
-        blobs = results[-1]
-        return blobs

aperturedb/BoundingBoxes.py

@@ -1,23 +1,7 @@
 from __future__ import annotations
-from typing import Dict
 
-from aperturedb.Connector import Connector
 from aperturedb.Entities import Entities
-from aperturedb.Query import Query
 
 
 class BoundingBoxes(Entities):
     db_object = "_BoundingBox"
-
-    @classmethod
-    def retrieve(cls,
-                 db: Connector,
-                 spec: Query,
-                 with_adjacent: Dict[str, Query] = None) -> BoundingBoxes:
-        spec.with_class = cls.db_object
-
-        results = Entities.retrieve(
-            db=db, spec=spec, with_adjacent=with_adjacent)
-
-        bboxes = results[-1]
-        return bboxes

aperturedb/Connector.py

@@ -63,7 +63,8 @@ def valid(self) -> bool:
         session_age = time.time() - self.session_started
 
         # This triggers refresh if the session is about to expire.
-        if session_age > self.session_token_ttl - os.getenv("SESSION_EXPIRTY_OFFSET_SEC", 10):
+        if session_age > self.session_token_ttl - \
+                int(os.getenv("SESSION_EXPIRTY_OFFSET_SEC", 10)):
             return False
 
         return True
@@ -160,12 +161,12 @@ def _authenticate(self, user, password="", token=""):
         if session_info["status"] != 0:
             raise Exception(session_info["info"])
 
-        self.shared_data.session = Session(session_info["session_token"],
-                                           session_info["refresh_token"],
-                                           session_info["session_token_expires_in"],
-                                           session_info["refresh_token_expires_in"],
-                                           time.time()
-                                           )
+        self.shared_data.session = Session(
+            session_info["session_token"],
+            session_info["refresh_token"],
+            session_info["session_token_expires_in"],
+            session_info["refresh_token_expires_in"],
+            time.time())
 
     def _check_session_status(self):
         if not self.shared_data.session:
@@ -190,12 +191,12 @@ def _refresh_token(self):
             if session_info["status"] != 0:
                 raise UnauthorizedException(response)
 
-            self.shared_data.session = Session(session_info["session_token"],
-                                               session_info["refresh_token"],
-                                               session_info["session_token_expires_in"],
-                                               session_info["refresh_token_expires_in"],
-                                               time.time()
-                                               )
+            self.shared_data.session = Session(
+                session_info["session_token"],
+                session_info["refresh_token"],
+                session_info["session_token_expires_in"],
+                session_info["refresh_token_expires_in"],
+                time.time())
         else:
             raise UnauthorizedException(response)
 
@@ -312,10 +313,13 @@ def query(self, q, blobs=[]):
         try:
             start = time.time()
             self.response, self.blobs = self._query(q, blobs)
-            if not isinstance(self.response, list) and self.response["info"] == "Not Authenticated!":
+            if not isinstance(
+                    self.response,
+                    list) and self.response["info"] == "Not Authenticated!":
                 # The case where session is valid, but expires while query is sent.
-                # Hope is that the query send won't be longer than the session ttl.
-                logger.warn(
+                # Hope is that the query send won't be longer than the session
+                # ttl.
+                logger.warning(
                     f"Session expired while query was sent. Retrying... \r\n{traceback.format_stack(limit=5)}")
                 self._renew_session()
                 start = time.time()
@@ -333,7 +337,7 @@ def _renew_session(self):
                 self._check_session_status()
                 break
             except UnauthorizedException as e:
-                logger.warn(
+                logger.warning(
                     f"[Attempt {count + 1} of 3] Failed to refresh token. Details: \r\n{traceback.format_exc(limit=5)}")
                 time.sleep(1)
                 count += 1

aperturedb/Entities.py

@@ -6,6 +6,7 @@
 from aperturedb.Constraints import Constraints
 from aperturedb.Connector import Connector
 from aperturedb.ParallelQuery import execute_batch
+from aperturedb.Query import QueryBuilder
 import pandas as pd
 
 
@@ -21,13 +22,13 @@ class Entities(Subscriptable):
     update_command = f"Update{db_object}"
 
     @classmethod
-    def retrieve(cls,
-                 db: Connector,
-                 spec: Query,
-                 with_adjacent: Dict[str, Query] = None
-                 ) -> List[Entities]:
+    def retrieve_entities(cls,
+                          db: Connector,
+                          spec: Query,
+                          with_adjacent: Dict[str, Query] = None
+                          ) -> List[Entities]:
         """
-        Using the Entities.retrieve method, is a simpple layer, with typical native queries converted
+        Using the Entities.retrieve method, is a simple layer, with typical native queries converted
         using :class:`~aperturedb.Query.Query`
 
         Args:
@@ -85,8 +86,7 @@ def retrieve(cls,
                 entities = cls.known_entities[wc](
                     db=db, response=subresponse, type=wc)
                 entities.blobs = blobs
-                if wc[0] == "_":
-                    entities.find_command = f"Find{wc[1:]}"
+
                 results.append(entities)
             except Exception as e:
                 print(e)
@@ -96,8 +96,25 @@ def retrieve(cls,
         cls.__postprocess__(entities=results[-1], with_adjacent=with_adjacent)
         return results
 
+    @classmethod
+    def retrieve(cls,
+                 db: Connector,
+                 spec: Query,
+                 with_adjacent: Dict[str, Query] = None) -> Entities:
+        spec.db_object = cls.db_object
+
+        results = Entities.retrieve_entities(
+            db=db, spec=spec, with_adjacent=with_adjacent)
+
+        # This is a very naive assumption, we will stop querying once
+        # the object of interest is the in the resopnses.
+        objects = results[-1]
+
+        return objects
+
     # This needs to be defined so that the application can access the adjacent items,
     # with every item of this iterable.
+
     @classmethod
     def __decorator(cls, index, adjacent):
         item = {}
@@ -180,27 +197,28 @@ def get_connected_entities(self,  etype: Union[ObjectType, str], constraints: Co
         result = []
         entity_class = etype.value if isinstance(etype, ObjectType) else etype
         for entity in self:
-            query = [
-                {
-                    self.find_command: {
-                        "_ref": 1,
-                        "unique": False,
-                        "constraints": {
-                            "_uniqueid": ["==", entity["_uniqueid"]]
-                        }
-                    }
-                }, {
-                    "FindEntity": {
-                        "is_connected_to": {
-                            "ref": 1
-                        },
-                        "with_class": entity_class,
-                        "constraints": constraints.constraints,
-                        "results": {
-                            "all_properties": True
-                        }
-                    }
+            params_src = {
+                "_ref": 1,
+                "unique": False,
+                "constraints": {
+                    "_uniqueid": ["==", entity["_uniqueid"]]
+                }
+            }
+            params_dst = {
+                "is_connected_to": {
+                    "ref": 1
+                },
+                "with_class": entity_class,
+                "constraints": constraints.constraints,
+                "results": {
+                    "all_properties": True
                 }
+            }
+
+            query = [
+                QueryBuilder.find_command(self.db_object, params=params_src),
+                QueryBuilder.find_command(
+                    oclass=entity_class, params=params_dst)
             ]
             res, r, b = execute_batch(query, [], self.db)
             cl = Entities
@@ -214,19 +232,18 @@ def get_blob(self, entity) -> Any:
         """
         Helper to get blobs for FindImage, FindVideo and FindBlob commands.
         """
-        query = [
-            {
-                self.find_command: {
-                    "constraints": {
-                        "_uniqueid": ["==", entity["_uniqueid"]]
-                    },
-                    "blobs": True,
-                    "uniqueids": True,
-                    "results": {
-                        "count": True
-                    }
-                }
+        cmd_params = {
+            "constraints": {
+                "_uniqueid": ["==", entity["_uniqueid"]]
+            },
+            "blobs": True,
+            "uniqueids": True,
+            "results": {
+                "count": True
             }
+        }
+        query = [
+            QueryBuilder().find_command(self.db_object, params=cmd_params)
         ]
         res, r, b = execute_batch(query, [], self.db)
         return b[0]

aperturedb/Images.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
-from typing import Dict, Tuple, Union
+from typing import Tuple, Union
 import cv2
 import math
 import numpy as np
 
 import matplotlib.pyplot as plt
 
 from aperturedb import Utils
-from aperturedb.Entities import Entities, ObjectType, Query
-from aperturedb.Connector import Connector
+from aperturedb.Entities import Entities
 from aperturedb.Constraints import Constraints
 from ipywidgets import widgets
 from IPython.display import display, HTML
@@ -23,23 +22,6 @@
 class Images(Entities):
     db_object = "_Image"
 
-    @classmethod
-    def retrieve(cls,
-                 db: Connector,
-                 spec: Query,
-                 with_adjacent: Dict[str, Query] = None) -> Images:
-        spec.with_class = cls.db_object
-
-        results = Entities.retrieve(
-            db=db, spec=spec, with_adjacent=with_adjacent)
-
-        # A Polygon is only connected to 1 image, and our query is filtered with
-        # meta info from polygon, so connect the right image to the polygon
-        # That being said, the ordering should be same as that of the first command in the query
-        images = results[-1]
-
-        return images
-
     def inspect(self, use_thumbnails=True) -> Union[Tuple[widgets.IntSlider, widgets.Output], DataFrame]:
         df = super(Images, self).inspect()
         if use_thumbnails:

aperturedb/Polygons.py

@@ -1,22 +1,11 @@
 from __future__ import annotations
-from aperturedb.Connector import Connector
 from aperturedb.Entities import Entities
-from aperturedb.Query import Query
 from aperturedb.ParallelQuery import execute_batch
 
 
 class Polygons(Entities):
     db_object = "_Polygon"
 
-    @classmethod
-    def retrieve(cls,
-                 db: Connector,
-                 spec: Query) -> Polygons:
-        polygons = Entities.retrieve(
-            db=db,
-            spec=spec)
-        return polygons[-1]
-
     def intersection(self, other: Polygons, threshold: float) -> Polygons:
         """
         Find a set of polygons that intersect with another set of polygons.

aperturedb/Query.py

@@ -49,8 +49,6 @@ class Query():
     This is the underlying class to generate a query using python code.
     """
     db_object = "Entity"
-    find_command = f"Find{db_object}"
-    update_command = f"Update{db_object}"
     next = None
 
     def connected_to(self,
@@ -142,33 +140,27 @@ def __init__(self,
 
     def query(self) -> List[dict]:
         results_section = "results"
-        cmd = {
-            self.find_command: {
-                "_ref": self.adj_to,
-                results_section: {
-
-                }
-            }
-        }
-        if self.db_object == "Entity":
-            cmd[self.find_command]["with_class"] = self.with_class
+        cmd_params = {results_section: {}}
         if self.limit != -1:
-            cmd[self.find_command][results_section]["limit"] = self.limit
+            cmd_params[results_section]["limit"] = self.limit
         if self.sort:
-            cmd[self.find_command][results_section]["sort"] = self.sort._sort
+            cmd_params[results_section]["sort"] = self.sort._sort
         if self.list is not None and len(self.list) > 0:
-            cmd[self.find_command][results_section]["list"] = self.list
+            cmd_params[results_section]["list"] = self.list
         else:
-            cmd[self.find_command][results_section]["all_properties"] = True
-        cmd[self.find_command][results_section]["group_by_source"] = self.group_by_src
+            cmd_params[results_section]["all_properties"] = True
+        cmd_params[results_section]["group_by_source"] = self.group_by_src
 
         if self.constraints:
-            cmd[self.find_command]["constraints"] = self.constraints.constraints
-
+            cmd_params["constraints"] = self.constraints.constraints
+        self.with_class = self.with_class if self.db_object == "Entity" else self.db_object
+        cmd = QueryBuilder.find_command(
+            oclass=self.with_class, params=cmd_params)
+        self.find_command = list(cmd.keys())[0]
         query = [cmd]
         if self.next:
             next_commands = self.next.query()
-            next_commands[0][self.next.find_command]["is_connected_to"] = {
+            list(next_commands[0].values())[0]["is_connected_to"] = {
                 "ref": self.adj_to
             }
             query.extend(next_commands)