Feature/visualizations (#164)

This updates the jupyter server built via the CI.
Other than that, it includes some helper functions for videos.

Author: gsaluja9

.gitignore

@@ -144,3 +144,5 @@ kaggleds/
 examples/*/kaggleds/
 docs/*/*.svg
 test/aperturedb/logs
+adb-python/*
+docker/notebook/aperturedata/*

aperturedb/Blobs.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from typing import Dict
 
 from aperturedb.Connector import Connector
 from aperturedb.Entities import Entities
@@ -9,5 +10,14 @@ class Blobs(Entities):
     db_object = "_Blob"
 
     @classmethod
-    def retrieve(cls, db: Connector, spec: Query) -> Blobs:
-        return super().retrieve(db, spec)[-1]
+    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,4 +1,5 @@
 from __future__ import annotations
+from typing import Dict
 
 from aperturedb.Connector import Connector
 from aperturedb.Entities import Entities
@@ -9,5 +10,14 @@ class BoundingBoxes(Entities):
     db_object = "_BoundingBox"
 
     @classmethod
-    def retrieve(cls, db: Connector, spec: Query) -> BoundingBoxes:
-        return super().retrieve(db, spec)[-1]
+    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/Constraints.py

@@ -20,6 +20,10 @@ def equal(self, key, value) -> Constraints:
         self.constraints[self._conjunction][key] = ["==", value]
         return self
 
+    def notequal(self, key, value) -> Constraints:
+        self.constraints[self._conjunction][key] = ["!=", value]
+        return self
+
     def greaterequal(self, key, value) -> Constraints:
         self.constraints[self._conjunction][key] = [">=", value]
         return self

aperturedb/Entities.py

@@ -23,7 +23,8 @@ class Entities(Subscriptable):
     @classmethod
     def retrieve(cls,
                  db: Connector,
-                 spec: Query
+                 spec: Query,
+                 with_adjacent: Dict[str, Query] = None
                  ) -> List[Entities]:
         """
         Using the Entities.retrieve method, is a simpple layer, with typical native queries converted
@@ -39,19 +40,41 @@ def retrieve(cls,
         Returns:
             List[Entities]: _description_
         """
+
+        # Since adjacent items are usually a way to filter the results,
+        # the native query is constructed in the reverse order, with
+        # first filtering out the relevant itmes based on adjacent items.
+        fs = None
+        count = 0
+        if with_adjacent:
+            for k, v in with_adjacent.items():
+                if fs is None:
+                    fs = v
+                else:
+                    fs = fs.connected_to(v)
+                count += 1
+            # Eventually, connect the specification of Images to the specification of the adjacent items.
+            fs = fs.connected_to(spec)
+        else:
+            fs = spec
+
+        spec = fs
+
         cls.known_entities = load_entities_registry(
             custom_entities=spec.command_properties(prop="with_class"))
         cls.db = db
-        if cls.db_object != "Entity":
-            spec.with_class = cls.db_object
 
         query = spec.query()
         print(f"query={query}")
         res, r, b = execute_batch(query, [], db)
         if res > 0:
             print(f"resp={r}")
         results = []
-        for wc, req, resp in zip(spec.command_properties(prop="with_class"), spec.command_properties(prop="find_command"), r):
+        for wc, req, blobs, resp in zip(
+                spec.command_properties(prop="with_class"),
+                spec.command_properties(prop="find_command"),
+                spec.command_properties(prop="blobs"),
+                r):
             subresponse = resp[req]['entities']
             if not isinstance(subresponse, list):
                 flattened = []
@@ -61,13 +84,39 @@ def retrieve(cls,
             try:
                 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)
                 print(cls.known_entities)
                 raise e
+
+        cls.__postprocess__(entities=results[-1], with_adjacent=with_adjacent)
         return results
 
+    # 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 = {}
+        for k, v in adjacent.items():
+            item[k] = v[index]
+        return item
+
+    @classmethod
+    def __postprocess__(cls, entities: Entities, with_adjacent: object = None):
+        adjacent = {}
+        if with_adjacent:
+            for k, v in with_adjacent.items():
+                adjacent[k] = entities.get_connected_entities(
+                    etype=v.with_class,
+                    constraints=v.constraints)
+
+            entities.decorator = cls.__decorator
+            entities.adjacent = adjacent
+
     def __init__(self, db: Connector = None, response: dict = None, type: str = None) -> None:
         super().__init__()
         self.db = db
@@ -99,7 +148,7 @@ def __sub__(self, other: Entities) -> Entities:
     def sort(self, key) -> Entities:
         return Entities(response = sorted(self.response, key=key), type=self.type)
 
-    def inspect(self) -> pd.DataFrame:
+    def inspect(self, **kwargs) -> pd.DataFrame:
         return pd.json_normalize([item for item in self])
 
     def update_properties(self, extra_properties: List[dict]) -> bool:
@@ -129,6 +178,7 @@ def get_connected_entities(self,  etype: Union[ObjectType, str], constraints: Co
             List[Entities]: _description_
         """
         result = []
+        entity_class = etype.value if isinstance(etype, ObjectType) else etype
         for entity in self:
             query = [
                 {
@@ -144,7 +194,7 @@ def get_connected_entities(self,  etype: Union[ObjectType, str], constraints: Co
                         "is_connected_to": {
                             "ref": 1
                         },
-                        "with_class": type.value,
+                        "with_class": entity_class,
                         "constraints": constraints.constraints,
                         "results": {
                             "all_properties": True
@@ -153,10 +203,34 @@ def get_connected_entities(self,  etype: Union[ObjectType, str], constraints: Co
                 }
             ]
             res, r, b = execute_batch(query, [], self.db)
-            result.append(self.known_entities[type.value](
-                db=self.db, response=r[1]["FindEntity"]["entities"], type=type.value))
+            cl = Entities
+            if entity_class in self.known_entities:
+                cl = self.known_entities[entity_class]
+            result.append(cl(
+                db=self.db, response=r[1]["FindEntity"]["entities"], type=entity_class))
         return result
 
+    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
+                    }
+                }
+            }
+        ]
+        res, r, b = execute_batch(query, [], self.db)
+        return b[0]
+
 
 def load_entities_registry(custom_entities: List[str] = None) -> dict:
     from aperturedb.Polygons import Polygons

aperturedb/Images.py

@@ -16,59 +16,28 @@
 from io import BytesIO
 from PIL import Image
 from pandas import DataFrame
+import logging
+logger = logging.getLogger(__name__)
 
 
 class Images(Entities):
     db_object = "_Image"
 
-    # 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 = {}
-        for k, v in adjacent.items():
-            item[k] = v[index]
-        return item
-
     @classmethod
     def retrieve(cls,
                  db: Connector,
                  spec: Query,
                  with_adjacent: Dict[str, Query] = None) -> Images:
         spec.with_class = cls.db_object
-        # Sice adjacent items are usually a way to filter the results,
-        # the native query is constructed in the reverse order, with
-        # first filtering out the relavant itmes based on adjacent items.
-        fs = None
-        count = 0
-        if with_adjacent:
-            for k, v in with_adjacent.items():
-                if fs is None:
-                    fs = v
-                else:
-                    fs = fs.connected_to(v)
-                count += 1
-            # Eventually, connect the specification of Images to the specification of the adjacent items.
-            fs = fs.connected_to(spec)
-        else:
-            fs = spec
-
-        results = Entities.retrieve(db=db, spec=fs)
+
+        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]
 
-        adjacent = {}
-        if with_adjacent:
-            for k, v in with_adjacent.items():
-                adjacent[k] = images.get_connected_entities(
-                    type=EntityType(v.with_class),
-                    constraints=v.constraints)
-
-            images.decorator = cls.__decorator
-            images.adjacent = adjacent
         return images
 
     def inspect(self, use_thumbnails=True) -> Union[Tuple[widgets.IntSlider, widgets.Output], DataFrame]:
@@ -102,7 +71,6 @@ def getitem(self, idx):
         if self.get_image == True:
             buffer = self.get_image_by_index(idx)
             if buffer is not None:
-                # nparr = np.frombuffer(buffer, dtype=np.uint8)
                 item['thumbnail'] = Image.fromarray(
                     self.get_np_image_by_index(idx))
         return item
@@ -308,7 +276,7 @@ def total_results(self):
     def get_image_by_index(self, index):
 
         if index >= len(self.images_ids):
-            print("Index is incorrect")
+            logger.info("Index is incorrect")
             return
 
         uniqueid = self.images_ids[index]