ref: remove mode from DBInterrogator

Author: paulmueller

CHANGELOG

@@ -14,6 +14,7 @@
  - enh: remove unused "Sharing" page
  - enh: add icon for "Find Data"
  - enh: cache CKANAPI instance in GUI
+ - ref: remove `mode` from `DBInterrogator`
  - ref: replace `user_list` with `user_autocomplete`
  - ref: replace `search_dataset` with `search_dataset_via_api`
    in `APIInterrogator`; `search_dataset` is now only free text search

dcoraid/dbmodel/db_api.py

@@ -22,33 +22,20 @@ class APIInterrogator(DBInterrogator):
     def __init__(self, api):
         self.api = api.copy()
         if api.user_id:
-            mode = "user"
             user_data = api.get_user_dict()
         else:
-            mode = "public"
             user_data = None
-        super(APIInterrogator, self).__init__(mode=mode, user_data=user_data)
+        super(APIInterrogator, self).__init__(user_data=user_data)
 
     def get_circles(self):
         """Return the list of DCOR Circle names
         """
-        if self.mode == "user":
-            # Organizations the user is a member of
-            circle_dict = self.api.get("organization_list_for_user",
-                                       id=self.api.user_id,
-                                       permission="read")
-            data = [dd["name"] for dd in circle_dict]
-        else:
-            data = self.api.get("organization_list")
+        data = self.api.get("organization_list")
         return data
 
     def get_collections(self):
         """Return the list of DCOR Collection names"""
-        if self.mode == "user":
-            collection_dict = self.api.get("group_list_authz", am_member=True)
-            data = [dd["name"] for dd in collection_dict]
-        else:
-            data = self.api.get("group_list")
+        data = self.api.get("group_list")
         if len(data) == 1000:
             raise NotImplementedError(
                 "Reached hard limit of 1000 results! "
@@ -57,50 +44,56 @@ def get_collections(self):
 
     def get_datasets_user_following(self):
         """Return datasets the user is following"""
-        assert self.mode == "user"
-        data = self.api.get("dataset_followee_list", id=self.api.user_name)
+        if self.api.user_id is not None:
+            data = self.api.get("dataset_followee_list", id=self.api.user_name)
+        else:
+            data = []
         return DBExtract(data)
 
     def get_datasets_user_owned(self):
         """Return datasets the user created"""
-        assert self.mode == "user"
-        dbextract = self.search_dataset_via_api(
-            filter_queries=[f"+creator_user_id:{self.api.user_id}"],
-            limit=0,
-        )
-        return dbextract
+        if self.api.user_id is not None:
+            dbe = self.search_dataset_via_api(
+                filter_queries=[f"+creator_user_id:{self.api.user_id}"],
+                limit=0,
+            )
+        else:
+            dbe = DBExtract()
+        return dbe
 
     def get_datasets_user_shared(self):
         """Return datasets shared with the user"""
-        assert self.mode == "user"
         # Perform a dataset search with all circles and collections.
         # This search may become too large (414 Request-URI Too Large).
         # Limit the search to 20 circles/collections.
-        dbextract = DBExtract()
+        dbe = DBExtract()
 
-        for circles_batch in batched(self.get_circles(), 20):
-            dbextract += self.search_dataset_via_api(
-                circles=list(circles_batch),
-                filter_queries=[f"-creator_user_id:{self.api.user_id}"],
-                limit=0,
-                )
+        if self.api.user_id is not None:
 
-        for collections_batch in batched(self.get_collections(), 20):
-            dbextract += self.search_dataset_via_api(
-                collections=list(collections_batch),
-                filter_queries=[f"-creator_user_id:{self.api.user_id}"],
-                limit=0,
-                )
+            for circles_batch in batched(self.get_circles(), 20):
+                dbe += self.search_dataset_via_api(
+                    circles=list(circles_batch),
+                    filter_queries=[f"-creator_user_id:{self.api.user_id}"],
+                    limit=0,
+                    )
 
-        # all packages the user is a collaborator in
-        collaborated = self.api.get("package_collaborator_list_for_user",
-                                    id=self.user_data["id"])
-        for col in collaborated:
-            if col["package_id"] not in dbextract:
-                ds_dict = self.api.get("package_show", id=col["package_id"])
-                dbextract.add_datasets([ds_dict])
+            for collections_batch in batched(self.get_collections(), 20):
+                dbe += self.search_dataset_via_api(
+                    collections=list(collections_batch),
+                    filter_queries=[f"-creator_user_id:{self.api.user_id}"],
+                    limit=0,
+                    )
 
-        return dbextract
+            # all packages the user is a collaborator in
+            collaborated = self.api.get("package_collaborator_list_for_user",
+                                        id=self.user_data["id"])
+            for col in collaborated:
+                if col["package_id"] not in dbe:
+                    ds_dict = self.api.get("package_show",
+                                           id=col["package_id"])
+                    dbe.add_datasets([ds_dict])
+
+        return dbe
 
     def get_users(self, ret_fullnames=False):
         """Return the list of DCOR users"""
@@ -237,16 +230,17 @@ def search_dataset_via_api(self,
 
         num_total = np.inf  # just the initial value
         num_retrieved = 0
-        dbextract = DBExtract()
+        dbe = DBExtract()
         while start + num_retrieved < min(start + limit, num_total) and rows:
-            data = self.api.get("package_search",
-                                q=urllib.parse.quote(query, safe=""),
-                                fq=final_fq,
-                                include_private=(self.mode == "user"),
-                                rows=rows,
-                                sort=sort_solr,
-                                start=start + num_retrieved,
-                                )
+            data = self.api.get(
+                "package_search",
+                q=urllib.parse.quote(query, safe=""),
+                fq=final_fq,
+                include_private=bool(self.api.user_id is not None),
+                rows=rows,
+                sort=sort_solr,
+                start=start + num_retrieved,
+                )
             if np.isinf(num_total):
                 # first iteration
                 num_total = data["count"]
@@ -255,9 +249,9 @@ def search_dataset_via_api(self,
                 # in the next iteration, only get the final
                 # few results.
                 rows = num_total - num_retrieved
-            dbextract.add_datasets(data["results"])
+            dbe.add_datasets(data["results"])
 
-        return dbextract
+        return dbe
 
     def update(self, reset=False):
         """Ignored, since no local database exists"""

dcoraid/dbmodel/db_api_cached.py

@@ -28,10 +28,8 @@ def __init__(self, api, cache_location):
         }
 
         if api.user_id:
-            mode = "user"
             user_data = api.get_user_dict()
         else:
-            mode = "public"
             user_data = None
 
         self._mc = MetaCache(self.cache_location)
@@ -40,8 +38,7 @@ def __init__(self, api, cache_location):
         self._mc_version_path = self.cache_location / "cache_version"
         self._mc_version_path.touch()
 
-        super(CachedAPIInterrogator, self).__init__(mode=mode,
-                                                    user_data=user_data)
+        super(CachedAPIInterrogator, self).__init__(user_data=user_data)
 
     @property
     def local_timestamp(self):

dcoraid/dbmodel/db_core.py

@@ -2,15 +2,14 @@
 
 
 class DBInterrogator(abc.ABC):
-    def __init__(self, mode, user_data):
-        if mode == "user":
+    def __init__(self, user_data):
+        if user_data:
             mandatory = ["id", "name", "number_created_packages"]
             missing = [key for key in mandatory if key not in user_data]
             if missing:
                 raise ValueError("The following keys are missing in "
-                                 f"`user_data` for `mode=='user'`: {missing}")
+                                 f"`user_data`: {missing}")
         self.user_data = user_data
-        self.mode = mode
         self.search_query = {}
 
     @property
@@ -39,8 +38,6 @@ def get_collections(self):
 
     def get_datasets_user(self):
         """Return DBExtract with data owned by or shared with the user"""
-        if self.mode != "user":
-            raise ValueError("Cannot get user datasets if mode is 'public'!")
         owned = self.get_datasets_user_owned()
         shared = self.get_datasets_user_shared()
         following = self.get_datasets_user_following()

dcoraid/gui/panel_find_data/widget_find_data.py

@@ -41,10 +41,10 @@ def on_search(self):
         mv.check_update_database()
         if mv.database:
             self.setCursor(QtCore.Qt.CursorShape.WaitCursor)
-            dbextract = self.database.search_dataset(
+            dbe = self.database.search_dataset(
                 self.lineEdit_search.text(),
                 limit=self.spinBox_public_rows.value())
-            self.public_filter_chain.set_db_extract(dbextract)
+            self.public_filter_chain.set_db_extract(dbe)
             self.setCursor(QtCore.Qt.CursorShape.ArrowCursor)
 
     @QtCore.pyqtSlot()