geoseeq 0.7.3.dev0__py3-none-any.whl → 0.7.3.dev2__py3-none-any.whl

geoseeq/dashboard/dashboard.py

@@ -3,7 +3,9 @@ from typing import Literal
 
 from geoseeq import ProjectResultFile
 from geoseeq.id_constructors import result_file_from_blob
+from geoseeq.id_constructors.from_ids import result_file_from_id
 from geoseeq.remote_object import RemoteObject
+from geoseeq import GeoseeqNotFoundError
 
 logger = logging.getLogger("geoseeq_api")
 
@@ -12,134 +14,212 @@ class Dashboard(RemoteObject):
     parent_field = "project"
     remote_fields = ["is_default"]
 
-    def __init__(self, knex, project, name="Default dashboard", is_default=False):
+    def __init__(
+        self, knex, project, title="Default dashboard", default=False, tiles=[]
+    ):
         super().__init__(self)
         self.knex = knex
         self.project = project
-        self._name = name
-        self.tiles = []
-        self.is_default = is_default
+        self.title = title
+        self._original_title = title
+        self.tiles = tiles
+        self.default = default
 
     def _get(self, allow_overwrite=False):
         blob = self.knex.get(f"sample_groups/{self.project.uuid}/dashboard-list")
-        blob = blob["dashboard_data"][self.name]
+        if self.title not in blob["dashboard_data"].keys():
+            raise GeoseeqNotFoundError(f"Dashboard '{self.title}' not found.")
+        blob = blob["dashboard_data"][self.title]
         for tile_blob in blob["tiles"]:
             tile = DashboardTile.from_blob(self, tile_blob)
             self.tiles.append(tile)
         blob.pop("tiles")
         self.load_blob(blob, allow_overwrite=allow_overwrite)
 
-    def _save(self):
+    def save(self):
+        put_data = {
+            "name": self._original_title,
+            "is_default": self.default,
+            "new_name": self.title,
+        }
+        self.knex.put(
+            f"sample_groups/{self.project.uuid}/dashboard-list",
+            json=put_data,
+            json_response=False,
+        )
+        self._original_title = self.title
         self.save_tiles()
 
     def save_tiles(self):
         post_data = {"tiles": [tile._get_post_data() for tile in self.tiles]}
-        blob = self.knex.post(
-            f"sample_groups/{self.project.uuid}/dashboard/{self.name}/tiles",
+        self.knex.post(
+            f"sample_groups/{self.project.uuid}/dashboard/{self._original_title}/tiles",
             json=post_data,
             json_response=False,
         )
-        print(blob)
 
     def _create(self):
-        post_data = {"name": self.name, "is_default": self.is_default}
-        blob = self.knex.post(
-            f"sample_groups/{self.project.uuid}/dashboard", json=post_data
+        post_data = {"name": self.title, "is_default": self.default}
+        self.knex.post(
+            f"sample_groups/{self.project.uuid}/dashboard-list", json=post_data
         )
-        self.load_blob(blob)
 
-    def tile(
+    def add_tile(
         self,
-        title,
         result_file,
-        style: Literal["col-span-1", "col-span-2"] = "col-span-1",
+        title,
+        width: Literal["hafl", "full"] = "half",
     ):
+        style = "col-span-1" if width == "half" else "col-span-2"
         result_file.get()
         tile = DashboardTile(self.knex, self, title, result_file, style=style)
         self.tiles.append(tile)
         self._modified = True
-        return tile
 
-    def add_tile(self, tile):
-        self.tiles.append(tile)
-        self._modified = True
-
-    @property
-    def name(self):
-        return self._name
+    def delete(self):
+        self.knex.delete(
+            f"sample_groups/{self.project.uuid}/dashboard-list?name={self._original_title}"
+        )
 
     def __str__(self):
-        return f'<Geoseeq Dashboard: {self.project.grn} "{self.name}"/>'
+        return f'<Geoseeq Dashboard: {self.project.grn} "{self._original_title}"/>'
 
     def __repr__(self):
         return str(self)
 
     @property
     def grn(self):
-        return f'grn:dashboard:{self.project.uuid}:"{self.name}"'
+        return f'grn:dashboard:{self.project.uuid}:"{self._original_title}"'
 
     def pre_hash(self):
-        return "DASH" + self.project.uuid + self.name
+        return "DASH" + self.project.uuid + self._original_title
+
+
+class DashboardTile:
+    def __init__(self, knex, dashboard, title, result_file, style="col-span-1"):
+        self.knex = knex
+        self.dashboard = dashboard
+        self.title = title
+        self.style = style
+        self.result_file = result_file
+
+    def _get_post_data(self):
+        out = {
+            "field_uuid": self.result_file.uuid,
+            "field_type": (
+                "group" if isinstance(self.result_file, ProjectResultFile) else "sample"
+            ),
+            "style": self.style,
+            "title": self.title,
+            "has_related_field": False,
+        }
+        return out
+
+    @classmethod
+    def from_blob(cls, dashboard, blob):
+        result_file = result_file_from_blob(dashboard.knex, blob["viz_field"])
+        return cls(
+            dashboard.knex, dashboard, blob["title"], result_file, style=blob["style"]
+        )
+
+    def __str__(self) -> str:
+        return f'<Geoseeq DashboardTile: {self.dashboard.grn} "{self.title}" />'
+
+    def __repr__(self) -> str:
+        return str(self)
 
 
 class SampleDashboard(RemoteObject):
     """Dashboard client for a single sample."""
 
     parent_field = "sample"
-    remote_fields = ["is_default"]
+    remote_fields = ["uuid", "title", "default", "created_at", "updated_at"]
 
-    def __init__(self, knex, sample, name="Default dashboard", is_default=False):
+    def __init__(self, knex, sample, title="Default dashboard", default=False):
         super().__init__(self)
         self.knex = knex
         self.sample = sample
-        self._name = name
+        self.title = title
         self.tiles = []
-        self.is_default = is_default
+        self.default = default
 
     def _get(self, allow_overwrite=False):
-        blob = self.knex.get(f"samples/{self.sample.uuid}/dashboard-list")
-        blob = blob["dashboard_data"][self.name]
-        for tile_blob in blob["tiles"]:
-            tile = DashboardTile.from_blob(self, tile_blob)
-            self.tiles.append(tile)
-        blob.pop("tiles")
+        blob = self.knex.get(f"samples/{self.sample.uuid}/dashboards")
+        try:
+            blob = [
+                dashboard_blob
+                for dashboard_blob in blob["results"]
+                if dashboard_blob["title"] == self.title
+            ][0]
+        except IndexError:
+            raise ValueError(f"There is no existing dashboard with title {self.title}")
+
         self.load_blob(blob, allow_overwrite=allow_overwrite)
 
-    def _save(self):
+        # Load tiles
+        tiles_res = self.knex.get(f"samples/dashboards/{self.uuid}/tiles")
+        for tile_blob in tiles_res["results"]:
+            tile = SampleDashboardTile.from_blob(self, tile_blob)
+            self.tiles.append(tile)
+
+    def save(self):
+        data = self._get_post_data()
+        url = f"samples/{self.sample.uuid}/dashboards/{self.uuid}"
+        self.knex.put(url, json=data)
         self.save_tiles()
 
     def save_tiles(self):
         post_data = {"tiles": [tile._get_post_data() for tile in self.tiles]}
-        self.knex.post(
-            f"samples/{self.sample.uuid}/dashboard/{self.name}/tiles",
+        self.knex.put(
+            f"samples/dashboards/{self.uuid}/tiles",
             json=post_data,
             json_response=False,
         )
 
+    def delete(self):
+        self.knex.delete(f"samples/{self.sample.uuid}/dashboards/{self.uuid}")
+        self._already_fetched = False
+        self._deleted = True
+
     def _create(self):
-        post_data = {"name": self.name, "is_default": self.is_default}
-        blob = self.knex.post(f"samples/{self.sample.uuid}/dashboard", json=post_data)
+        post_data = {
+            "title": self.title,
+            "sample": self.sample.uuid,
+            "default": self.default,
+        }
+        blob = self.knex.post(f"samples/{self.sample.uuid}/dashboards", json=post_data)
         self.load_blob(blob)
 
-    def tile(
-        self,
-        title,
-        result_file,
-        style: Literal["col-span-1", "col-span-2"] = "col-span-1",
-    ):
+    def _get_post_data(self):
+        out = {
+            "sample": self.sample.uuid,
+            "title": self.title,
+            "default": self.default,
+        }
+        return out
+
+    def add_tile(self, result_file, title, width="half", order=None):
         result_file.get()
-        tile = DashboardTile(self.knex, self, title, result_file, style=style)
+        tile = SampleDashboardTile(
+            self.knex, self, title, result_file, width=width, order=order
+        )
         self.tiles.append(tile)
         self._modified = True
-        return tile
 
-    def add_tile(self, tile):
-        self.tiles.append(tile)
-        self._modified = True
+    @classmethod
+    def from_blob(cls, sample, blob):
+        instance = cls(
+            sample.knex,
+            sample,
+            blob["title"],
+            blob["default"],
+        )
+        instance.uuid = blob["uuid"]
+        return instance
 
     @property
     def name(self):
-        return self._name
+        return self.title
 
     def __str__(self):
         return f'<Geoseeq SampleDashboard: {self.sample.brn} "{self.name}"/>'
@@ -155,32 +235,35 @@ class SampleDashboard(RemoteObject):
         return "DASH" + self.sample.uuid + self.name
 
 
-class DashboardTile:
-
-    def __init__(self, knex, dashboard, title, result_file, style="col-span-1"):
+class SampleDashboardTile:
+    def __init__(self, knex, dashboard, title, result_file, width="half", order=None):
         self.knex = knex
         self.dashboard = dashboard
         self.title = title
-        self.style = style
+        self.width = width
         self.result_file = result_file
+        self.order = order
 
     def _get_post_data(self):
         out = {
-            "field_uuid": self.result_file.uuid,
-            "field_type": (
-                "group" if isinstance(self.result_file, ProjectResultFile) else "sample"
-            ),
-            "style": self.style,
+            "field": self.result_file.uuid,
+            "dashboard": self.dashboard.uuid,
+            "width": self.width,
             "title": self.title,
-            "has_related_field": False,
+            "order": self.order,
         }
         return out
 
     @classmethod
     def from_blob(cls, dashboard, blob):
-        result_file = result_file_from_blob(dashboard.knex, blob["viz_field"])
+        result_file = result_file_from_id(dashboard.knex, blob["field_obj"]["uuid"])
         return cls(
-            dashboard.knex, dashboard, blob["title"], result_file, style=blob["style"]
+            dashboard.knex,
+            dashboard,
+            blob["title"],
+            result_file,
+            width=blob["width"],
+            order=blob["order"],
         )
 
     def __str__(self) -> str:

geoseeq/project.py

@@ -3,6 +3,7 @@ import urllib
 
 import pandas as pd
 
+
 from .pipeline import Pipeline
 from .remote_object import RemoteObject
 from .result import ProjectResultFolder
@@ -59,11 +60,23 @@ class Project(RemoteObject):
         self._modified = True
 
     def get_post_data(self):
-        data = {field: getattr(self, field) for field in self.remote_fields if hasattr(self, field)}
+        data = {
+            field: getattr(self, field)
+            for field in self.remote_fields
+            if hasattr(self, field)
+        }
         data["organization"] = self.org.uuid
-        data['description'] = self.description if hasattr(self, 'description') and self.description else self.name
-        data['privacy_level'] = self.privacy_level if hasattr(self, 'privacy_level') and self.privacy_level else 'private'
-        data['storage_provider_name'] = self.storage_provider
+        data["description"] = (
+            self.description
+            if hasattr(self, "description") and self.description
+            else self.name
+        )
+        data["privacy_level"] = (
+            self.privacy_level
+            if hasattr(self, "privacy_level") and self.privacy_level
+            else "private"
+        )
+        data["storage_provider_name"] = self.storage_provider
         if self.new_org:
             if isinstance(self.new_org, RemoteObject):
                 data["organization"] = self.new_org.uuid
@@ -90,7 +103,9 @@ class Project(RemoteObject):
             url = f"sample_groups/{self.uuid}/samples"
             chunk_size = 100
             for i in range(0, len(sample_uuids), chunk_size):
-                self.knex.post(url, json={"sample_uuids": sample_uuids[i : i + chunk_size]})
+                self.knex.post(
+                    url, json={"sample_uuids": sample_uuids[i : i + chunk_size]}
+                )
         self._sample_cache = []
 
     def _delete_sample_list(self):
@@ -126,7 +141,7 @@ class Project(RemoteObject):
             json=post_data,
         )
         self.load_blob(blob)
-    
+
     def add_sample_uuids(self, sample_uuids):
         """Return this group and add a sample to this group.
 
@@ -166,7 +181,7 @@ class Project(RemoteObject):
 
     def analysis_result(self, *args, **kwargs):
         """Return a ProjectResultFolder object for this project.
-        
+
         Alias for result_folder."""
         return self.result_folder(*args, **kwargs)
 
@@ -177,7 +192,9 @@ class Project(RemoteObject):
                 yield sample
             return
         url = f"sample_groups/{self.uuid}/samples-list?page=1&page_size=100"
-        for sample_blob in paginated_iterator(self.knex, url, error_handler=error_handler):
+        for sample_blob in paginated_iterator(
+            self.knex, url, error_handler=error_handler
+        ):
             sample = self.sample(sample_blob["name"])
             sample.uuid = sample_blob["uuid"]
             sample.metadata = sample_blob["metadata"]
@@ -199,12 +216,16 @@ class Project(RemoteObject):
                 yield sample.uuid
             return
         url = f"sample_groups/{self.uuid}/samples-list?page=1"
-        for sample_blob in paginated_iterator(self.knex, url, error_handler=error_handler):
-            yield sample_blob['uuid']
+        for sample_blob in paginated_iterator(
+            self.knex, url, error_handler=error_handler
+        ):
+            yield sample_blob["uuid"]
 
     def _batch_sample_uuids(self, batch_size, input_sample_uuids=[]):
         """Yield batches of sample uuids."""
-        uuids_to_batch = input_sample_uuids if input_sample_uuids else self.get_sample_uuids()
+        uuids_to_batch = (
+            input_sample_uuids if input_sample_uuids else self.get_sample_uuids()
+        )
         sample_uuids = []
         for sample_uuid in uuids_to_batch:
             sample_uuids.append(sample_uuid)
@@ -216,7 +237,7 @@ class Project(RemoteObject):
 
     def get_analysis_results(self, cache=True):
         """Yield ProjectResultFolder objects for this project fetched from the server.
-        
+
         Alias for get_result_folders."""
         return self.get_result_folders(cache=cache)
 
@@ -262,24 +283,25 @@ class Project(RemoteObject):
             rows.extend(blob["results"])
             url = blob["next"]
         return pd.DataFrame(rows)
-    
-    
+
     @property
     def n_samples(self):
         """Return the number of samples in this project."""
-        if hasattr(self, 'samples_count') and self.samples_count is not None:
+        if hasattr(self, "samples_count") and self.samples_count is not None:
             return self.samples_count
         return len(list(self.get_sample_uuids()))
-    
-    def bulk_find_files(self,
-                        sample_uuids=[],
-                        sample_name_includes=[],
-                        folder_types="all",
-                        folder_names=[],
-                        file_names=[],
-                        extensions=[],
-                        with_versions=False,
-                        use_batches_cutoff=500):
+
+    def bulk_find_files(
+        self,
+        sample_uuids=[],
+        sample_name_includes=[],
+        folder_types="all",
+        folder_names=[],
+        file_names=[],
+        extensions=[],
+        with_versions=False,
+        use_batches_cutoff=500,
+    ):
         """Return a dict with links to download files that match the given criteria.
 
         Options:
@@ -291,36 +313,48 @@ class Project(RemoteObject):
         - extensions: list of strings; finds files with these file extensions
         - with_versions: bool; if True, include all versions of files in results
         """
+
         def _my_bulk_find(sample_uuids=None):  # curry to save typing
-            return self._bulk_find_files_batch(sample_uuids=sample_uuids or [],
-                                             sample_name_includes=sample_name_includes,
-                                             folder_types=folder_types,
-                                             folder_names=folder_names,
-                                             file_names=file_names,
-                                             extensions=extensions,
-                                             with_versions=with_versions)
+            return self._bulk_find_files_batch(
+                sample_uuids=sample_uuids or [],
+                sample_name_includes=sample_name_includes,
+                folder_types=folder_types,
+                folder_names=folder_names,
+                file_names=file_names,
+                extensions=extensions,
+                with_versions=with_versions,
+            )
+
         n_samples = len(sample_uuids) if sample_uuids else self.n_samples
         if n_samples < use_batches_cutoff:
             logger.debug(f"Using single batch bulk_find for {n_samples} samples")
             return _my_bulk_find(sample_uuids=sample_uuids)
         else:
             logger.debug(f"Using multi batch bulk_find for {n_samples} samples")
-            merged_response = {'file_size_bytes': 0, 'links': {}, 'no_size_info_count': 0}
-            for batch in self._batch_sample_uuids(use_batches_cutoff - 1, input_sample_uuids=sample_uuids):
+            merged_response = {
+                "file_size_bytes": 0,
+                "links": {},
+                "no_size_info_count": 0,
+            }
+            for batch in self._batch_sample_uuids(
+                use_batches_cutoff - 1, input_sample_uuids=sample_uuids
+            ):
                 response = _my_bulk_find(sample_uuids=batch)
-                merged_response['file_size_bytes'] += response['file_size_bytes']
-                merged_response['links'].update(response['links'])
-                merged_response['no_size_info_count'] += response['no_size_info_count']
+                merged_response["file_size_bytes"] += response["file_size_bytes"]
+                merged_response["links"].update(response["links"])
+                merged_response["no_size_info_count"] += response["no_size_info_count"]
             return merged_response
-                
-    def _bulk_find_files_batch(self,
-                               sample_uuids=None,
-                               sample_name_includes=None,
-                               folder_types=None,
-                               folder_names=None,
-                               file_names=None,
-                               extensions=None,
-                               with_versions=False):
+
+    def _bulk_find_files_batch(
+        self,
+        sample_uuids=None,
+        sample_name_includes=None,
+        folder_types=None,
+        folder_names=None,
+        file_names=None,
+        extensions=None,
+        with_versions=False,
+    ):
         data = {
             "sample_uuids": sample_uuids or [],
             "sample_names": sample_name_includes or [],
@@ -328,22 +362,105 @@ class Project(RemoteObject):
             "folder_names": folder_names or [],
             "file_names": file_names or [],
             "extensions": extensions or [],
-            "with_versions": with_versions
+            "with_versions": with_versions,
         }
         url = f"sample_groups/{self.uuid}/download"
         response = self.knex.post(url, data)
         return response
-    
+
     def run_app(self, app: Pipeline, input_parameters=None):
         """Run an app on this group."""
         if not input_parameters:
             input_parameters = app.get_input_parameters()
         params = {
-            'pipeline_id': app.uuid,
-            'sample_uuids': list(self.get_sample_uuids()),
-            'input_parameters': input_parameters,
+            "pipeline_id": app.uuid,
+            "sample_uuids": list(self.get_sample_uuids()),
+            "input_parameters": input_parameters,
         }
-        self.knex.post(f"sample_groups/{self.uuid}/run_app", json=params, json_response=False)
+        self.knex.post(
+            f"sample_groups/{self.uuid}/run_app", json=params, json_response=False
+        )
+
+    def create_dashboard(self, title="Default dashboard", default=False):
+        """Create a dashboard for this project."""
+        from geoseeq.dashboard.dashboard import Dashboard
+
+        post_data = {"name": title, "is_default": default}
+        self.knex.post(f"sample_groups/{self.uuid}/dashboard-list", json=post_data)
+
+        return Dashboard(knex=self.knex, project=self, title=title, default=default)
+
+    def get_default_dashbaord(self):
+        """Get the default dashboard for this project."""
+        from geoseeq.dashboard.dashboard import Dashboard, DashboardTile
+
+        resp = self.knex.get(f"sample_groups/{self.uuid}/dashboard-list")
+        try:
+            dashboard_name = [
+                name
+                for name, data in resp["dashboard_data"].items()
+                if data["is_default"] == True
+            ][0]
+            blob = resp["dashboard_data"][dashboard_name]
+            tiles = []
+            for tile_blob in blob["tiles"]:
+                tile = DashboardTile.from_blob(self, tile_blob)
+                tiles.append(tile)
+            dashboard = Dashboard(
+                self.knex,
+                project=self,
+                title=dashboard_name,
+                default=blob["is_default"],
+                tiles=tiles,
+            )
+            return dashboard
+        except IndexError:
+            logger.warning("Default dashboard not found.")
+            pass
+        return None
+
+    def get_or_create_default_dashbaord(self):
+        """Get the default dashboard for this project or create it if does not exist."""
+        default_dashboard = self.get_default_dashbaord()
+        if default_dashboard:
+            return default_dashboard
+        else:
+            return self.create_dashboard(default=True)
+
+    def get_dashbaord_by_title(self, title):
+        """Get dashboard for this project by the title of the dashboard."""
+        from geoseeq.dashboard.dashboard import Dashboard, DashboardTile
+
+        resp = self.knex.get(f"sample_groups/{self.uuid}/dashboard-list")
+        try:
+            dashboard_name = [
+                name for name in resp["dashboard_data"].keys() if name == title
+            ][0]
+            blob = resp["dashboard_data"][dashboard_name]
+            tiles = []
+            for tile_blob in blob["tiles"]:
+                tile = DashboardTile.from_blob(self, tile_blob)
+                tiles.append(tile)
+            dashboard = Dashboard(
+                knex=self.knex,
+                project=self,
+                title=dashboard_name,
+                default=blob["is_default"],
+                tiles=tiles,
+            )
+            return dashboard
+        except IndexError:
+            logger.warning(f"Dashboard {title} not found.")
+            pass
+        return None
+
+    def get_or_create_dashbaord_by_title(self, title: str):
+        """Get dashboard by title for this project or create it if does not exist."""
+        default_dashboard = self.get_dashbaord_by_title(title)
+        if default_dashboard:
+            return default_dashboard
+        else:
+            return self.create_dashboard(title=title, default=False)
 
     def __str__(self):
         return f"<Geoseeq::Project {self.name} {self.uuid} />"
@@ -353,7 +470,7 @@ class Project(RemoteObject):
 
     def pre_hash(self):
         return "PROJ" + self.name + self.org.pre_hash()
-    
+
     @property
     def grn(self):
         return f"grn::project:{self.uuid}"
@@ -363,4 +480,5 @@ class Project(RemoteObject):
         self._modified = True
         return self
 
-SampleGroup = Project  # alias for backwards compatibility
+
+SampleGroup = Project  # alias for backwards compatibility

geoseeq/sample.py

@@ -1,5 +1,4 @@
 import urllib
-
 from .remote_object import RemoteObject
 from .result import SampleResultFile, SampleResultFolder
 
@@ -32,7 +31,7 @@ class Sample(RemoteObject):
 
     @property
     def brn(self):
-        return f'brn:{self.knex.instance_code()}:sample:{self.uuid}'
+        return f"brn:{self.knex.instance_code()}:sample:{self.uuid}"
 
     def nested_url(self):
         escaped_name = urllib.parse.quote(self.name, safe="")
@@ -63,15 +62,19 @@ class Sample(RemoteObject):
             self.load_blob(blob, allow_overwrite=allow_overwrite)
 
     def get_post_data(self):
-        data = {field: getattr(self, field) for field in self.remote_fields if hasattr(self, field)}
+        data = {
+            field: getattr(self, field)
+            for field in self.remote_fields
+            if hasattr(self, field)
+        }
         data["library"] = self.lib.uuid
         if self.new_lib:
             if isinstance(self.new_lib, RemoteObject):
                 data["library"] = self.new_lib.uuid
             else:
                 data["library"] = self.new_lib
-        if data['uuid'] is None:
-            data.pop('uuid')
+        if data["uuid"] is None:
+            data.pop("uuid")
         return data
 
     def _create(self):
@@ -96,10 +99,10 @@ class Sample(RemoteObject):
 
     def analysis_result(self, *args, **kwargs):
         """Return a SampleResultFolder for this sample.
-        
+
         This is an alias for result_folder."""
         return self.result_folder(*args, **kwargs)
-    
+
     def get_result_folders(self, cache=True):
         """Yield sample analysis results fetched from the server."""
         self.get()
@@ -107,7 +110,7 @@ class Sample(RemoteObject):
             for ar in self._get_result_cache:
                 yield ar
             return
-        url =  f"sample_ars?sample_id={self.uuid}"
+        url = f"sample_ars?sample_id={self.uuid}"
         result = self.knex.get(url)
         for result_blob in result["results"]:
             result = self.analysis_result(result_blob["module_name"])
@@ -126,7 +129,7 @@ class Sample(RemoteObject):
 
     def get_analysis_results(self, cache=True):
         """Yield sample analysis results fetched from the server.
-        
+
         This is an alias for get_result_folders.
         """
         return self.get_result_folders(cache=cache)
@@ -135,14 +138,15 @@ class Sample(RemoteObject):
         """Return a manifest for this sample."""
         url = f"samples/{self.uuid}/manifest"
         return self.knex.get(url)
-    
+
     def _grn_to_file(self, grn):
         from geoseeq.id_constructors.from_blobs import sample_result_file_from_blob
+
         file_uuid = grn.split(":")[-1]
         file_blob = self.knex.get(f"sample_ar_fields/{file_uuid}")
         file = sample_result_file_from_blob(self.knex, file_blob)
         return file
-    
+
     def get_one_fastq(self):
         """Return a 2-ple, a fastq ResultFile and a string with the read type.
 
@@ -152,10 +156,10 @@ class Sample(RemoteObject):
         blob = self.knex.get(url)
         file = self._grn_to_file(blob["grn"])
         return file, blob["read_type"]
-    
+
     def get_one_fastq_folder(self, preference_order=None):
         """Return a 3-ple, <read_type:str>, <folder_name:str>, a list with reads.
-        
+
         If the read type is paired end, the list will contain 2-ples with reads.
 
         Default preference order is:
@@ -175,7 +179,7 @@ class Sample(RemoteObject):
                 for folder_name, reads in all_fastqs[read_type].items():
                     return read_type, folder_name, reads
         raise ValueError("No suitable fastq found")
-    
+
     def get_all_fastqs(self):
         """Return a dict with the following structure:
 
@@ -217,7 +221,7 @@ class Sample(RemoteObject):
                         self._grn_to_file(file_grns[0])
                     )
         return files
-    
+
     def get_one_fasta(self):
         """Return a 2-ple, a fasta ResultFile and a string with the read type.
 
@@ -228,6 +232,75 @@ class Sample(RemoteObject):
         file = self._grn_to_file(blob["grn"])
         return file, blob["read_type"]
 
+    def create_dashboard(self, title="Default dashboard", default=False):
+        "Create a new dashboard for the sample"
+        from geoseeq.dashboard.dashboard import SampleDashboard
+
+        post_data = {
+            "title": title,
+            "sample": self.uuid,
+            "default": default,
+        }
+        blob = self.knex.post(f"samples/{self.uuid}/dashboards", json=post_data)
+        dashboard = SampleDashboard(
+            self.knex, self, title=blob["title"], default=blob["default"]
+        )
+        dashboard.uuid = blob["uuid"]
+        dashboard._already_fetched = True
+        return dashboard
+
+    def get_default_dashbaord(self):
+        """Get the default dashboard for this sample."""
+        from geoseeq.dashboard.dashboard import SampleDashboard
+
+        dashboard_resp = self.knex.get(f"samples/{self.uuid}/dashboards")
+        try:
+            blob = [
+                dashboard_blob
+                for dashboard_blob in dashboard_resp["results"]
+                if dashboard_blob["default"] == True
+            ][0]
+            dashboard = SampleDashboard.from_blob(self, blob)
+            dashboard.get()  # Tiles are not in the blob
+            return dashboard
+        except IndexError:
+            pass
+        return None
+
+    def get_or_create_default_dashbaord(self):
+        """Get the default dashboard for this sample or create it if does not exist."""
+        default_dashboard = self.get_default_dashbaord()
+        if default_dashboard:
+            return default_dashboard
+        else:
+            return self.create_dashboard(default=True)
+
+    def get_dashbaord_by_title(self, title):
+        """Get dashboard by title for this sample."""
+        from geoseeq.dashboard.dashboard import SampleDashboard
+
+        dashboard_resp = self.knex.get(f"samples/{self.uuid}/dashboards")
+        try:
+            blob = [
+                dashboard_blob
+                for dashboard_blob in dashboard_resp["results"]
+                if dashboard_blob["title"] == title
+            ][0]
+            dashboard = SampleDashboard.from_blob(self, blob)
+            dashboard.get()  # Tiles are not in the blob
+            return dashboard
+        except IndexError:
+            pass
+        return None
+
+    def get_or_create_dashbaord_by_title(self, title):
+        """Get dashboard by title for this sample or create it if does not exist."""
+        default_dashboard = self.get_dashbaord_by_title(title)
+        if default_dashboard:
+            return default_dashboard
+        else:
+            return self.create_dashboard(title=title)
+
     def __str__(self):
         return f"<Geoseeq::Sample {self.name} {self.uuid} />"
 

{geoseeq-0.7.3.dev0.dist-info → geoseeq-0.7.3.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geoseeq
-Version: 0.7.3.dev0
+Version: 0.7.3.dev2
 Summary: GeoSeeq command line tools and python API
 Project-URL: Homepage, https://github.com/biotia/geoseeq_api_client
 Project-URL: Issues, https://github.com/biotia/geoseeq_api_client/issues

{geoseeq-0.7.3.dev0.dist-info → geoseeq-0.7.3.dev2.dist-info}/RECORD

@@ -7,9 +7,9 @@ geoseeq/file_system_cache.py,sha256=HzVZWtwLD2fjWWSo_UfWmGeBltm9He4lP_OqzKwNGWg,
 geoseeq/knex.py,sha256=zcjafsmUn9SC3LlRnvvaXpr-pHYZ0IXk7LpzuUoE3MI,8312
 geoseeq/organization.py,sha256=bJkYL8_D-k6IYAaii2ZbxjwYnXy6lvu6iLXscxKlA3w,2542
 geoseeq/pipeline.py,sha256=89mhWaecsKnm6tyRkdkaVp4dmZh62_v42Ze0oXf8OTY,9873
-geoseeq/project.py,sha256=_8uttLKc6yVGDdJhPRmQOzzPeMYmUg0zBBPOAJc3yyo,14014
+geoseeq/project.py,sha256=GMAO3BQKz_L5Se4JmK0wpj7dp6ell8a-rF9tHNy2gfg,17068
 geoseeq/remote_object.py,sha256=GYN6PKU7Zz3htIdpFjfZiFejzGqqJHbJyKlefM1Eixk,7151
-geoseeq/sample.py,sha256=HAfMiDPHp1UJgIA2lI6oGnNit4YKyj7nx9X07CCN98U,8316
+geoseeq/sample.py,sha256=fBHpVDf8tRH8PBCW-nuNv0sNA4epvwUrlcTPy5im8FY,10895
 geoseeq/search.py,sha256=gawad6Cx5FxJBPlYkXWb-UKAO-UC0_yhvyU9Ca1kaNI,3388
 geoseeq/smart_table.py,sha256=rihMsFUIn-vn4w6ukVZTHI9bjDSEr8xHExBfX8mwCHM,6169
 geoseeq/smart_tree.py,sha256=bSjDlwmOuNXutYJhytA1RovwRCHV6ZxXXJPiIGFhPaA,1825
@@ -52,7 +52,7 @@ geoseeq/contrib/ncbi/api.py,sha256=WQeLoGA_-Zha-QeSO8_i7HpvXyD8UkV0qc5okm11KiA,1
 geoseeq/contrib/ncbi/bioproject.py,sha256=_oThTd_iLDOC8cLOlJKAatSr362OBYZCEV3YrqodhFg,4341
 geoseeq/contrib/ncbi/cli.py,sha256=j9zEcaZPTryK3a4xluRxigcJKDhRpRxbp3KZSx-Bfhk,2400
 geoseeq/contrib/ncbi/setup_logging.py,sha256=Tp1bY1U0f-o739aHpvVYriG2qdd1lFvCYBXZeXQgt-w,175
-geoseeq/dashboard/dashboard.py,sha256=0ISzcTby35oJVsOCeg4b_7Em6hRsh3QzsnbChf946Eo,5564
+geoseeq/dashboard/dashboard.py,sha256=mIlaqrSdy0C2EqpJVFvUKJkU1EiHluAT1DqfO0wvHb8,8336
 geoseeq/file_system/filesystem_download.py,sha256=8bcnxjWltekmCvb5N0b1guBIjLp4-CL2VtsEok-snv4,16963
 geoseeq/file_system/main.py,sha256=4HgYGq7WhlF96JlVIf16iFBTDujlBpxImmtoh4VCzDA,3627
 geoseeq/id_constructors/__init__.py,sha256=w5E0PNQ9UuAxBeZbDI7KBnUoERd85gGz3nScz45bd2o,126
@@ -92,8 +92,8 @@ geoseeq/vc/vc_cache.py,sha256=P4LXTbq2zOIv1OhP7Iw5MmypR2vXuy29Pq5K6gRvi-M,730
 geoseeq/vc/vc_dir.py,sha256=A9CLTh2wWCRzZjiLyqXD1vhtsWZGD3OjaMT5KqlfAXI,457
 geoseeq/vc/vc_sample.py,sha256=qZeioWydXvfu4rGMs20nICfNcp46y_XkND-bHdV6P5M,3850
 geoseeq/vc/vc_stub.py,sha256=IQr8dI0zsWKVAeY_5ybDD6n49_3othcgfHS3P0O9tuY,3110
-geoseeq-0.7.3.dev0.dist-info/METADATA,sha256=GqNnxtN09jNv5HRMkxGp5D8ZfrJUyJdxlzL5-6N2Ogw,5415
-geoseeq-0.7.3.dev0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-geoseeq-0.7.3.dev0.dist-info/entry_points.txt,sha256=yF-6KDM8zXib4Al0qn49TX-qM7PUkWUIcYtsgt36rjM,45
-geoseeq-0.7.3.dev0.dist-info/licenses/LICENSE,sha256=IuhIl1XCxXLPLJT_coN1CNqQU4Khlq7x4IdW7ioOJD8,1067
-geoseeq-0.7.3.dev0.dist-info/RECORD,,
+geoseeq-0.7.3.dev2.dist-info/METADATA,sha256=EMB21hKhfr8zcdmuWTe3dOWyi2GZe1-50DdGOwtUDB8,5415
+geoseeq-0.7.3.dev2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+geoseeq-0.7.3.dev2.dist-info/entry_points.txt,sha256=yF-6KDM8zXib4Al0qn49TX-qM7PUkWUIcYtsgt36rjM,45
+geoseeq-0.7.3.dev2.dist-info/licenses/LICENSE,sha256=IuhIl1XCxXLPLJT_coN1CNqQU4Khlq7x4IdW7ioOJD8,1067
+geoseeq-0.7.3.dev2.dist-info/RECORD,,