geoseeq 0.7.0__py3-none-any.whl → 0.7.2__py3-none-any.whl

geoseeq/cli/main.py

@@ -55,7 +55,7 @@ def version():
     Use of this tool implies acceptance of the GeoSeeq End User License Agreement.
     Run `geoseeq eula show` to view the EULA.
     """
-    click.echo('0.7.0')  # remember to update pyproject.toml
+    click.echo('0.7.2')  # remember to update pyproject.toml
 
 
 @main.group('advanced')

geoseeq/cli/upload/upload.py

@@ -128,9 +128,9 @@ def cli_upload_file(state, cores, threads_per_upload, num_retries, chunk_size_mb
     )
     for geoseeq_file_name, file_path in name_pairs:
         if isfile(file_path):
-            upload_manager.add_local_file_to_result_folder(result_folder, file_path)
+            upload_manager.add_local_file_to_result_folder(result_folder, file_path, geoseeq_file_name=geoseeq_file_name)
         elif isdir(file_path) and recursive:
-            upload_manager.add_local_folder_to_result_folder(result_folder, file_path, recursive=recursive, hidden_files=hidden, prefix=file_path)
+            upload_manager.add_local_folder_to_result_folder(result_folder, file_path, recursive=recursive, hidden_files=hidden, prefix=file_path, geoseeq_file_name=geoseeq_file_name)
         elif isdir(file_path) and not recursive:
             raise click.UsageError('Cannot upload a folder without --recursive')
     click.echo(upload_manager.get_preview_string(), err=True)

geoseeq/cli/upload/upload_reads.py

@@ -238,7 +238,7 @@ def cli_upload_reads_wizard(state, cores, overwrite, yes, regex, private, link_t
     filepaths = {basename(line): line for line in flatten_list_of_fastxs(fastq_files)}
     click.echo(f'Found {len(filepaths)} files to upload.', err=True)
     regex = _get_regex(knex, filepaths, module_name, proj, regex)
-    groups = _group_files(knex, filepaths, module_name, regex, yes)
+    groups = _group_files(knex, filepaths, module_name, regex, yes, name_map)
     _do_upload(groups, module_name, link_type, proj, filepaths, overwrite, no_new_versions, cores, state)
 
 

geoseeq/dashboard/dashboard.py

@@ -0,0 +1,103 @@
+
+import logging
+import json
+from typing import Literal
+from geoseeq.remote_object import RemoteObject
+from geoseeq.id_constructors import result_file_from_blob
+from geoseeq import ProjectResultFile
+
+logger = logging.getLogger("geoseeq_api")
+
+
+class Dashboard(RemoteObject):
+    parent_field = "project"
+    remote_fields = ["is_default"]
+
+    def __init__(self, knex, project, name="Default dashboard", is_default=False):
+        super().__init__(self)
+        self.knex = knex
+        self.project = project
+        self._name = name
+        self.tiles = []
+        self.is_default = is_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]
+        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):
+        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", 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)
+        self.load_blob(blob)
+    
+    def tile(self, title, result_file, style: Literal["col-span-1", "col-span-2"]="col-span-1"):
+        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 __str__(self):
+        return f"<Geoseeq Dashboard: {self.project.grn} \"{self.name}\"/>"
+    
+    def __repr__(self):
+        return str(self)
+    
+    @property
+    def grn(self):
+        return f"grn:dashboard:{self.project.uuid}:\"{self.name}\""
+    
+    def pre_hash(self):
+        return "DASH" + self.project.uuid + self.name
+
+
+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(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)

geoseeq/file_system/filesystem_download.py

@@ -0,0 +1,434 @@
+
+import os
+import json
+from geoseeq import (
+    result_file_from_id,
+    result_folder_from_id,
+    sample_from_id,
+    project_from_id,
+)
+from geoseeq.utils import md5_checksum
+from time import time
+
+FILE_STATUS_MODIFIED_REMOTE = 'MODIFIED_REMOTE'
+FILE_STATUS_MODIFIED_LOCAL = 'MODIFIED_LOCAL'
+FILE_STATUS_NEW_LOCAL = 'NEW_LOCAL'
+FILE_STATUS_NEW_REMOTE = 'NEW_REMOTE'
+FILE_STATUS_IS_LOCAL_STUB = 'IS_LOCAL_STUB'
+
+
+def dedupe_modified_files(modified_files):
+    """Remove duplicates from a list of modified files.
+    
+    This function will remove duplicates from a list of modified files
+    based on the path to the file. The first instance of the file will be
+    kept and all others will be removed.
+    """
+    seen = set()
+    deduped = []
+    for x in modified_files:
+        if x[2] not in seen:
+            deduped.append(x)
+            seen.add(x[2])
+    return deduped
+
+
+class ResultFileOnFilesystem:
+    """
+
+    Note: unlike other filesystem classes the `path` is a file, not
+    a directory. This is because the file is downloaded directly to 
+    the path.
+    """
+
+    def __init__(self, result_file, path, kind):
+        self.result_file = result_file
+        self.path = path
+        self.kind = kind
+
+    @property
+    def info_filepath(self):
+        dirpath = os.path.dirname(self.path)
+        basename = os.path.basename(self.path)
+        return os.path.join(dirpath, f'.gs_result_file__{basename}')
+    
+    @property
+    def is_stub(self):
+        return os.path.exists(self.path) and os.path.getsize(self.path) == 0
+    
+    def file_is_ok(self, stubs_are_ok=False):
+        if self.is_stub:
+            return stubs_are_ok
+        return self.result_file.download_needs_update(self.path)
+
+    def download(self, use_stubs=False, exists_ok=False):
+        if os.path.exists(self.info_filepath):
+            if exists_ok and self.file_is_ok(stubs_are_ok=use_stubs):
+                return
+            elif not exists_ok:
+                raise ValueError('Result file already exists at path: {}'.format(self.info_filepath))
+        
+        # Download the file
+        if use_stubs:
+            open(self.path, 'w').close()
+        else:
+            self.result_file.download(self.path)
+
+        self.write_info_file()
+
+    def local_file_checksum(self):
+        if self.is_stub:
+            return "__STUB__"
+        return md5_checksum(self.path)
+    
+    def locally_modified(self):
+        raise NotImplementedError('This function is not implemented')
+
+    def status_is_ok(self, stubs_are_ok=False):
+        # check for an info file
+        if not os.path.exists(self.info_filepath):
+            return False
+        if stubs_are_ok:
+            return True
+        return not self.result_file.download_needs_update(self.path)
+    
+    def write_info_file(self):
+        result_file_info = {
+            "uuid": self.result_file.uuid,
+            "kind": self.kind,
+            "checksum": self.local_file_checksum(),
+        }
+        with open(self.info_filepath, 'w') as f:
+            json.dump(result_file_info, f)
+
+    @classmethod
+    def from_path(cls, path):
+        obj = cls(None, path, None)
+        try:
+            with open(obj.info_filepath, 'r') as f:
+                result_file_info = json.load(f)
+            obj.result_file = result_file_from_id(result_file_info['uuid'])
+            obj.kind = result_file_info['kind']
+            obj.stored_checksum = result_file_info['checksum']
+        except FileNotFoundError:
+            pass
+        return obj
+    
+    def write_info_file(self):
+        result_file_info = {
+            "uuid": self.result_file.uuid,
+            "kind": self.kind,
+            "checksum": self.local_file_checksum(),
+        }
+        with open(self.info_filepath, 'w') as f:
+            json.dump(result_file_info, f)
+    
+    def list_abnormal_objects(self):
+        """Return a list of files that have been modified.
+        
+        Since this class is a single file the list will either be empty
+        or have one element.
+
+        Note that if a file was modified locally then uploaded to the server
+        the file will be marked as modified remote.
+        """
+        if self.result_file is None:
+            return [('FILE', FILE_STATUS_NEW_LOCAL, self.path, None)]
+        if not os.path.exists(self.path):
+            return [('FILE', FILE_STATUS_NEW_REMOTE, self.path, self.result_file)]
+        if self.is_stub:
+            return [('FILE', FILE_STATUS_IS_LOCAL_STUB, self.path, self.result_file)]
+        if self.result_file and self.result_file.download_needs_update(self.path):
+            return [('FILE', FILE_STATUS_MODIFIED_REMOTE, self.path, self.result_file)]
+        if self.locally_modified():
+            return [('FILE', FILE_STATUS_MODIFIED_LOCAL, self.path, self.result_file)]
+
+        return []
+
+    
+class ResultFolderOnFilesystem:
+
+    def __init__(self, result_folder, path, kind):
+        self.result_folder = result_folder
+        self.path = path
+        self.kind = kind
+
+    @property
+    def info_filepath(self):
+        return os.path.join(self.path, '.gs_result_folder')
+
+    def download(self, use_stubs=False, exists_ok=False):
+        if os.path.exists(self.info_filepath) and not exists_ok:
+            raise ValueError('Result folder already exists at path: {}'.format(self.info_filepath))
+        
+        # Download the files in the result folder
+        for result_file in self.result_folder.get_fields():
+            result_file_local_path = os.path.join(self.path, result_file.name)
+            os.makedirs(os.path.dirname(result_file_local_path), exist_ok=True)
+            ResultFileOnFilesystem(result_file, result_file_local_path, self.kind)\
+                .download(use_stubs=use_stubs, exists_ok=exists_ok)
+        
+        # Write the result folder data
+        result_folder_info = {
+            "uuid": self.result_folder.uuid,
+            "kind": self.kind
+        }
+        with open(self.info_filepath, 'w') as f:
+            json.dump(result_folder_info, f)
+
+    def status_is_ok(self):
+        # check for an info file
+        if not os.path.exists(self.info_filepath):
+            return False
+        
+        # check that all files are downloaded
+        for result_file in self.result_folder.get_files():
+            result_file_path = os.path.join(self.path, result_file.name)
+            if not os.path.exists(result_file_path):
+                return False
+        
+        return True
+    
+    @classmethod
+    def from_path(cls, path):
+        obj = cls(None, path, None)
+        try:
+            with open(os.path.join(path, '.gs_result_folder'), 'r') as f:
+                result_folder_info = json.load(f)
+            obj.result_folder = result_folder_from_id(result_folder_info['uuid'])
+            obj.kind = result_folder_info['kind']
+        except FileNotFoundError:
+            pass
+        return obj
+    
+    def list_abnormal_objects(self):
+        """Return a list of files that have been modified.
+        
+        This function will return a list of tuples where the first element
+        is the status of the file and the second element is the path to the file.
+        """
+        modified_files = []
+        if not self.result_folder:
+            modified_files.append(('FOLDER', FILE_STATUS_NEW_LOCAL, self.path, None))
+        if not os.path.exists(self.path):
+            modified_files.append(('FOLDER', FILE_STATUS_NEW_REMOTE, self.path, self.result_folder))
+
+        # list local files
+        if os.path.exists(self.path):
+            for local_file in os.listdir(self.path):
+                if local_file.startswith('.gs_'):
+                    continue
+                local_file_path = os.path.join(self.path, local_file)
+                result_file_on_fs = ResultFileOnFilesystem.from_path(local_file_path)
+                modified_files.extend(result_file_on_fs.list_abnormal_objects())
+
+        # list remote files
+        if self.result_folder:
+            for result_file in self.result_folder.get_fields():
+                result_file_path = os.path.join(self.path, result_file.name)
+                result_file_on_fs = ResultFileOnFilesystem(result_file, result_file_path, self.kind)
+                modified_files.extend(result_file_on_fs.list_abnormal_objects())
+    
+        return dedupe_modified_files(modified_files)
+    
+
+class SampleOnFilesystem:
+
+    def __init__(self, sample, path):
+        self.sample = sample
+        self.path = path if path[-1] != '/' else path[:-1]  # remove trailing slash
+
+    @property
+    def info_filepath(self):
+        return os.path.join(self.path, '.gs_sample')
+
+    def download(self, use_stubs=False, exists_ok=False):
+        if os.path.exists(self.info_filepath) and not exists_ok:
+            raise ValueError('Sample already exists at path: {}'.format(self.info_filepath))
+        
+        # download result folders
+        for result_folder in self.sample.get_result_folders():
+            result_folder_local_path = os.path.join(self.path, result_folder.name)
+            os.makedirs(result_folder_local_path, exist_ok=True)
+            ResultFolderOnFilesystem(result_folder, result_folder_local_path, "sample")\
+                .download(use_stubs=use_stubs, exists_ok=exists_ok)
+
+        # Write the sample data
+        sample_info = {
+            "uuid": self.sample.uuid
+        }
+        with open(self.info_filepath, 'w') as f:
+            json.dump(sample_info, f)
+
+    def status_is_ok(self):
+        # check for an info file
+        if not os.path.exists(self.info_filepath):
+            return False
+        
+        # check that all result folders are downloaded
+        for result_folder in self.sample.get_result_folders():
+            result_folder_local_path = os.path.join(self.path, result_folder.name)
+            result_folder_on_fs = ResultFolderOnFilesystem.from_path(result_folder_local_path, "sample")
+            if not result_folder_on_fs.status_is_ok():
+                return False
+        
+        return True
+
+    @classmethod
+    def from_path(cls, path):
+        obj = cls(None, path)
+        try:
+            with open(os.path.join(path, '.gs_sample'), 'r') as f:
+                sample_info = json.load(f)
+            obj.sample = sample_from_id(sample_info['uuid'])
+        except FileNotFoundError:
+            pass
+        return obj
+    
+    def list_abnormal_objects(self):
+        """Return a list of files that have been modified.
+        
+        This function will return a list of tuples where the first element
+        is the status of the file and the second element is the path to the file.
+        """
+        modified_files = []
+        if not self.sample:
+            modified_files.append(('SAMPLE', FILE_STATUS_NEW_LOCAL, self.path, None))
+        if not os.path.exists(self.path):
+            modified_files.append(('SAMPLE', FILE_STATUS_NEW_REMOTE, self.path, self.sample))
+
+        # list local folders
+        if os.path.exists(self.path):
+            for local_folder in os.listdir(self.path):
+                local_folder_path = os.path.join(self.path, local_folder)
+                if not os.path.isdir(local_folder_path):
+                    continue
+                result_folder_on_fs = ResultFolderOnFilesystem.from_path(local_folder_path)
+                modified_files.extend(result_folder_on_fs.list_abnormal_objects())
+
+        # list remote folders
+        if self.sample:
+            for result_folder in self.sample.get_result_folders():
+                result_folder_path = os.path.join(self.path, result_folder.name)
+                result_folder_on_fs = ResultFolderOnFilesystem(result_folder, result_folder_path, "sample")
+                modified_files.extend(result_folder_on_fs.list_abnormal_objects())
+
+        return dedupe_modified_files(modified_files)
+
+
+class ProjectOnFilesystem:
+
+    def __init__(self, project, path):
+        self.project = project
+        self.path = path
+
+    @property
+    def info_filepath(self):
+        return os.path.join(self.path, '.gs_project')
+
+    def download(self, use_stubs=False, exists_ok=False):
+        if os.path.exists(self.info_filepath) and not exists_ok:
+            raise ValueError('Project already exists at path: {}'.format(self.info_filepath))
+        
+        # download samples
+        for sample in self.project.get_samples():
+            sample_local_path = os.path.join(self.path, "sample_results", sample.name)
+            os.makedirs(sample_local_path, exist_ok=True)
+            SampleOnFilesystem(sample, sample_local_path)\
+                .download(use_stubs=use_stubs, exists_ok=exists_ok)
+        
+        # download project result folders
+        for result_folder in self.project.get_result_folders():
+            result_folder_local_path = os.path.join(self.path, "project_results", result_folder.name)
+            os.makedirs(result_folder_local_path, exist_ok=True)
+            ResultFolderOnFilesystem(result_folder, result_folder_local_path, "project")\
+                .download(use_stubs=use_stubs, exists_ok=exists_ok)
+
+        # Write the project data
+        project_info = {
+            "uuid": self.project.uuid
+        }
+        with open(self.info_filepath, 'w') as f:
+            json.dump(project_info, f)
+
+    def status_is_ok(self):
+        # check for an info file
+        if not os.path.exists(self.info_filepath):
+            return False
+        
+        # check that all samples are downloaded
+        for sample in self.project.get_samples():
+            sample_local_path = os.path.join(self.path, "sample_results", sample.name)
+            sample_on_fs = SampleOnFilesystem.from_path(sample_local_path)
+            if not sample_on_fs.status_is_ok():
+                return False
+        
+        # check that all project result folders are downloaded
+        for result_folder in self.project.get_result_folders():
+            result_folder_local_path = os.path.join(self.path, "project_results", result_folder.name)
+            result_folder_on_fs = ResultFolderOnFilesystem.from_path(result_folder_local_path, "project")
+            if not result_folder_on_fs.status_is_ok():
+                return False
+        
+        return True
+
+    @classmethod
+    def from_path(cls, path, recursive=False):
+        try:
+            with open(os.path.join(path, '.gs_project'), 'r') as f:
+                project_info = json.load(f)
+            project = project_from_id(project_info['uuid'])
+            return cls(project, path)
+        except FileNotFoundError:
+            if not recursive:
+                raise ValueError('No project found in path or parent directories')
+            updir = os.path.dirname(os.path.abspath(path))
+            if updir == path:
+                raise ValueError('No project found in path or parent directories')
+            return cls.from_path(updir, recursive=recursive)
+        
+    def path_from_project_root(self, path):
+        if path[0] == "/":
+            return path.replace(self.path, "")[1:]
+        return path
+
+    def list_abnormal_objects(self):
+        """Return a list of files that have been modified.
+        
+        This function will return a list of tuples where the first element
+        is the status of the file and the second element is the path to the file.
+        """
+        modified_files = []
+
+        # list remote samples
+        for sample in self.project.get_samples():
+            sample_path = os.path.join(self.path, "sample_results", sample.name)
+            sample_on_fs = SampleOnFilesystem(sample, sample_path)
+            modified_files.extend(sample_on_fs.list_abnormal_objects())
+
+        # list remote project result folders
+        for result_folder in self.project.get_result_folders():
+            result_folder_path = os.path.join(self.path, "project_results", result_folder.name)
+
+            result_folder_on_fs = ResultFolderOnFilesystem(result_folder, result_folder_path, "project")
+            modified_files.extend(result_folder_on_fs.list_abnormal_objects())
+
+        # list local samples
+        for local_sample in os.listdir(os.path.join(self.path, "sample_results")):
+            local_sample_path = os.path.join(self.path, "sample_results", local_sample)
+            if not os.path.isdir(local_sample_path):
+                continue
+            sample_on_fs = SampleOnFilesystem.from_path(local_sample_path)
+            modified_files.extend(sample_on_fs.list_abnormal_objects())
+
+        # list local project result folders
+        for local_result_folder in os.listdir(os.path.join(self.path, "project_results")):
+            local_result_folder_path = os.path.join(self.path, "project_results", local_result_folder)
+            if not os.path.isdir(local_result_folder_path):
+                continue
+            result_folder_on_fs = ResultFolderOnFilesystem.from_path(local_result_folder_path)
+            modified_files.extend(result_folder_on_fs.list_abnormal_objects())
+        return dedupe_modified_files(modified_files)
+                
+
+

geoseeq/file_system/main.py

@@ -0,0 +1,122 @@
+from fuse import FUSE, Operations
+import os
+
+
+class GeoSeeqProjectFileSystem(Operations):
+    """Mount a GeoSeeq project as a filesystem.
+    
+    The project will automatically have this directory structure:
+    - <root>/project_results/<project_result_folder_name>/...
+    - <root>/sample_results/<sample_name>/...
+    - <root>/metadata/sample_metadata.csv
+    - <root>/.config/config.json
+    """
+
+    def __init__(self, root, project):
+        self.root = root
+        self.project = project
+
+    def access(self, path, mode):
+        pass
+
+    def chmod(self, path, mode):
+        pass
+
+    def chown(self, path, uid, gid):
+        pass
+
+    def getattr(self, path, fh=None):
+        pass
+
+    def readdir(self, path, fh):
+        pass
+
+    def readlink(self, path):
+        pass
+
+    def mknod(self, path, mode, dev):
+        pass
+
+    def rmdir(self, path):
+        pass
+
+    def mkdir(self, path, mode):
+        pass
+
+    def statfs(self, path):
+        pass
+
+    def unlink(self, path):
+        pass
+
+    def symlink(self, name, target):
+        pass
+
+    def rename(self, old, new):
+        pass
+
+    def link(self, target, name):
+        pass
+
+    def utimens(self, path, times=None):
+        pass
+
+    def open(self, path, flags):
+        tkns = path.split('/')
+        if tkns[0] == 'project_results':
+            result_folder_name, result_file_name = tkns[2], '/'.join(tkns[3:])
+            result_folder = self.project.get_result_folder(result_folder_name).get()
+            result_file = result_folder.get_file(result_file_name).get()
+            result_file.download(path)
+        elif tkns[0] == 'sample_results':
+            sample_name, result_folder_name, result_file_name = tkns[2], tkns[3], '/'.join(tkns[4:])
+            sample = self.project.get_sample(sample_name).get()
+            result_folder = sample.get_result_folder(result_folder_name).get()
+            result_file = result_folder.get_file(result_file_name).get()
+            result_file.download(path)
+        elif tkns[0] == 'metadata':
+            raise NotImplementedError('TODO')
+        
+        return os.open(self._full_local_path(path), flags)
+
+    def create(self, path, mode, fi=None):
+        tkns = path.split('/')
+        if tkns[0] == 'project_results':
+            result_name, file_name = tkns[2], '/'.join(tkns[3:])
+            result_folder = self.project.get_result_folder(result_name).idem()
+            result_file = result_folder.get_file(file_name).create()
+            result_file.download(path)  # nothing to download at this point
+        elif tkns[0] == 'sample_results':
+            sample_name, result_folder_name, result_file_name = tkns[2], tkns[3], '/'.join(tkns[4:])
+            sample = self.project.get_sample(sample_name).idem()
+            result_folder = sample.get_result_folder(result_folder_name).idem()
+            result_file = result_folder.get_file(result_file_name).create()
+            result_file.download(path)  # nothing to download at this point
+        elif tkns[0] == 'metadata':
+            raise NotImplementedError('TODO')
+
+    def read(self, path, length, offset, fh):
+        os.lseek(fh, offset, os.SEEK_SET)
+        return os.read(fh, length)
+
+    def write(self, path, buf, offset, fh):
+        pass
+
+    def truncate(self, path, length, fh=None):
+        pass
+
+    def flush(self, path, fh):
+        pass
+
+    def release(self, path, fh):
+        pass
+
+    def fsync(self, path, fdatasync, fh):
+        pass
+    
+    def _full_local_path(self, partial):
+        if partial.startswith("/"):
+            partial = partial[1:]
+        return os.path.join(self.root, partial)
+
+    

geoseeq/plotting/README.md

@@ -0,0 +1,4 @@
+# GeoSeeq Plotting
+
+This subpackage contains functions related to plotting data.
+

geoseeq/vc/README.md

@@ -0,0 +1,48 @@
+# GeoSeeq Version Control
+
+GeoSeeq VC is a toolkit that makes it easy to use geoseeq with version control systems like `git`.
+
+Most of the files stored on GeoSeeq are too large to version control directly. This package creates lightweight stub files that record a files location and checksum. This package also contains tools to download files, and check that local files match those stored on the server. The stub files are small enough to version control directly.
+
+## CLI
+
+You can clone a project or sample from GeoSeeq. You will need to get the `brn` number from the project or sample then run these commands from your CLI 
+
+```
+geoseeq-api vc clone brn:gsr1:project:bed763fb-f6b8-4739-8320-95c06d68f442  # creates a directory tree with stub files
+geoseeq-api vc download  # downloads the files that the stubs link to
+geoseeq-api vc status  # checks that the local files match the files on GeoSeeq
+```
+
+If you are using git you probably want to add files from geoseeq to your `.gitignore`
+
+```
+geoseeq-api vc list >> .gitignore
+```
+
+## Shared Cache
+
+To avoid downloading or storing the same file multiple times users can specify a cache by setting the `GEOSEEQ_VC_CACHE_DIR` envvar to an absolute filepath. When set geoseeq will download files to a location in the cahce directory and create symlinks to those files.
+
+## Stub Files
+
+GeoSeeq interfaces with version control by creating small stub files that represent a larger file (AKA result field) stored on GeoSeeq. This package can be used to download those files and validate that the checksum of local files matches them. Since these files are small they can be easily stored with a version control system while the larger files can be ignored.
+
+The stub files are JSON and have the following structure:
+
+```
+{
+    "__schema_version__": "v0",
+    "brn": "brn:<instance name>:result_field:<uuid>",  # optional if stub is new and parent_info is set
+    "checksum": {
+        "value": "<value>",
+        "method": "md5",
+    },
+    "local_path": "<filename>",  # a filepath relative to the stub file
+    "parent_info": {  # optional if brn is set
+        "parent_obj_brn": "brn:<brn info>",
+        "result_module_name": <string>,
+        "result_module_replicate": <string>,
+    }  # NB if brn and parent_info are both set but disagree `brn` is correct
+}
+```

{geoseeq-0.7.0.dist-info → geoseeq-0.7.2.dist-info}/METADATA

@@ -1,24 +1,26 @@
 Metadata-Version: 2.4
 Name: geoseeq
-Version: 0.7.0
+Version: 0.7.2
 Summary: GeoSeeq command line tools and python API
-Author: David C. Danko
-Author-email: "David C. Danko" <dcdanko@biotia.io>
 Project-URL: Homepage, https://github.com/biotia/geoseeq_api_client
 Project-URL: Issues, https://github.com/biotia/geoseeq_api_client/issues
-Classifier: Programming Language :: Python :: 3
+Author-email: "David C. Danko" <dcdanko@biotia.io>
+License-File: LICENSE
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests
+Requires-Dist: biopython
 Requires-Dist: click
 Requires-Dist: pandas
-Requires-Dist: biopython
+Requires-Dist: requests
 Requires-Dist: tqdm
-Dynamic: author
-Dynamic: license-file
+Provides-Extra: test
+Requires-Dist: pytest-cov>=4.0; extra == 'test'
+Requires-Dist: pytest-mock>=3.10; extra == 'test'
+Requires-Dist: pytest>=7.0; extra == 'test'
+Requires-Dist: requests-mock>=1.11; extra == 'test'
+Description-Content-Type: text/markdown
 
 # Geoseeq API Client
 

{geoseeq-0.7.0.dist-info → geoseeq-0.7.2.dist-info}/RECORD

@@ -25,7 +25,7 @@ geoseeq/cli/download.py,sha256=Znjuc9IFOcIa5_Od9mFXHJdYAJtgw9Bc_wPPcOVXn7s,21298
 geoseeq/cli/fastq_utils.py,sha256=-bmeQLaiMBm57zWOF0R5OlWTU0_3sh1JBC1RYw2BOFM,3083
 geoseeq/cli/find_grn.py,sha256=oMDxkzGQBQb2_cCuvmwoeHOsFHqyO9RLeJzrB6bAe5M,439
 geoseeq/cli/get_eula.py,sha256=79mbUwyiF7O1r0g6UTxG9kJGQEqKuH805E6eLkPC6Y4,997
-geoseeq/cli/main.py,sha256=pkpjc_5dZ8T0F92777OKRXT_EFoHelfw4DhKjEcXqIE,3982
+geoseeq/cli/main.py,sha256=uGCf-uREHdrDzQZDiBLFt6KcKcyDRHnN6vHZRSwZaYU,3982
 geoseeq/cli/manage.py,sha256=wGXAcVaXqE5JQEU8Jh6OlHr02nB396bpS_SFcOZdrEo,5929
 geoseeq/cli/progress_bar.py,sha256=p1Xl01nkYxSBZCB30ue2verIIi22W93m3ZAMAxipD0g,738
 geoseeq/cli/project.py,sha256=V5SdXm2Hwo2lxrkpwRDedw-mAE4XnM2uwT-Gj1D90VQ,3030
@@ -42,15 +42,19 @@ geoseeq/cli/shared_params/id_handlers.py,sha256=KtzflnplYVkXsyqI5Ej6r-_BwQnuXVHP
 geoseeq/cli/shared_params/obj_getters.py,sha256=ZSkt6LnDkVFlNVYKgLrjzg60-6BthZMr3eeD3HNqzac,2741
 geoseeq/cli/shared_params/opts_and_args.py,sha256=_DcJ-TqgrbBaeDd-kuHEx2gLZPQN6EHZYWh8Ag-d8Vg,2091
 geoseeq/cli/upload/__init__.py,sha256=tRrljqG7uBM6zVBKpDw1zevHz6Vy418HuIYZKwByyWg,862
-geoseeq/cli/upload/upload.py,sha256=U9w18sG6dZ0uJoAMcQDLdrEtgmRaSaPS7-8KM5LkVd4,14220
+geoseeq/cli/upload/upload.py,sha256=tBga8TW_5qXM4avXH5BAfLrYNms_5eqdyJZex47hZ90,14294
 geoseeq/cli/upload/upload_advanced.py,sha256=1pjtbe8EidIo4eR1_oVD00rPCTxYj8CRqB8D9buA62M,12432
-geoseeq/cli/upload/upload_reads.py,sha256=m9ujcjSYOG88LhxMj1vEt8v7FpuhRciL4ntE6oNlVuM,11632
+geoseeq/cli/upload/upload_reads.py,sha256=dZK_Mh3a3NdC4zVB4Yyfz-NViCK9_rROQbmLWTrh8Pc,11642
 geoseeq/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+geoseeq/contrib/ncbi/README.md,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 geoseeq/contrib/ncbi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 geoseeq/contrib/ncbi/api.py,sha256=WQeLoGA_-Zha-QeSO8_i7HpvXyD8UkV0qc5okm11KiA,1056
 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=HOUJoQcFGLc3JL5UVIYETq6CkQEMP2I4WaPr2u9YV3Q,3297
+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
 geoseeq/id_constructors/from_blobs.py,sha256=wZp6P6m7X0lhZAQxorHKJQn1CTBvKyfANzu2VFexp44,6315
 geoseeq/id_constructors/from_ids.py,sha256=SRylajToFdnRON5EhPIvcAi64XuIzseaasZlOooqTpg,3984
@@ -58,6 +62,7 @@ geoseeq/id_constructors/from_names.py,sha256=RqgFjDsAwQcidMkZwX7oB00OvBAKTiilHYe
 geoseeq/id_constructors/from_uuids.py,sha256=loqTeZqDZuvfVVHpS7m-Y_spNaY3h9VRjt0wDiMxHbs,3522
 geoseeq/id_constructors/resolvers.py,sha256=8hp5xJSCoZrAXtMT54Hp4okt63l909XqJU3IQx-VCgc,2676
 geoseeq/id_constructors/utils.py,sha256=Up_vXoZDwa2mJGllJ6CmcbaOGUvA-sM0gMmFnXK8wn4,1255
+geoseeq/plotting/README.md,sha256=qlPnEzJWVxBeLvgyFXIN2du_-6GprvX8lRk4ROw6aMs,82
 geoseeq/plotting/__init__.py,sha256=RkGoXxgu7jEfK0B7NmdalPS2AbU7I7dZwDbi4rn9CKM,154
 geoseeq/plotting/constants.py,sha256=CGUlm8WAFG3YRKdicc9Rcy5hFxUdUm2RgK0iXZWLuX8,285
 geoseeq/plotting/highcharts.py,sha256=AGzdW4VSUsL_rfEI-RiVbbtaTLFMARvzLzVUDrKTlnU,4096
@@ -77,6 +82,7 @@ geoseeq/result/resumable_download_tracker.py,sha256=YEzqHBBnE7L3XokTvlTAhHZ8TcDT
 geoseeq/result/resumable_upload_tracker.py,sha256=2aI09gYz2yw63jEXqs8lmCRKQ79TIc3YuPETvP0Jeek,3811
 geoseeq/result/smart_objects.py,sha256=-krK9h9HcznIglf189uPghOidF_BzOeSxmBWxrtFFo8,1991
 geoseeq/result/utils.py,sha256=C-CxGzB3WddlnRiqFSkrY78I_m0yFgNqsTBRzGU-y8Q,2772
+geoseeq/vc/README.md,sha256=igLGXl1jpp2A_tTfPutspTejwE1lkObeCsSvCYPBqOM,2316
 geoseeq/vc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 geoseeq/vc/checksum.py,sha256=y8rh1asUZNbE_NLiFO0-9hImLNiTOc2YXQBRKORWK7k,710
 geoseeq/vc/cli.py,sha256=rUspr6FUJiUWIVMvf-pmyC5psKfufN45alk8392fAfA,2803
@@ -86,12 +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.0.dist-info/licenses/LICENSE,sha256=IuhIl1XCxXLPLJT_coN1CNqQU4Khlq7x4IdW7ioOJD8,1067
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_api_client.py,sha256=TS5njc5pcPP_Ycy-ljcfPVT1hQRBsFVdQ0lCqBmoesU,12810
-tests/test_plotting.py,sha256=TcTu-2ARr8sxZJ7wPQxmbs3-gHw7uRvsgrhhhg0qKik,784
-geoseeq-0.7.0.dist-info/METADATA,sha256=lEr_Lja53CYN53DTQTR3CKG3cqPdwgnuB03sbiwtzTs,4953
-geoseeq-0.7.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-geoseeq-0.7.0.dist-info/entry_points.txt,sha256=yF-6KDM8zXib4Al0qn49TX-qM7PUkWUIcYtsgt36rjM,45
-geoseeq-0.7.0.dist-info/top_level.txt,sha256=zZk7mmeaqAYqFJG8nq2DTgSQPbflRjJwkDIhNURPDEU,14
-geoseeq-0.7.0.dist-info/RECORD,,
+geoseeq-0.7.2.dist-info/METADATA,sha256=nBGfEYFfG9yWP6LWxczthpgwC5vZ5f7xi7VyaxVmz4Y,5107
+geoseeq-0.7.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+geoseeq-0.7.2.dist-info/entry_points.txt,sha256=yF-6KDM8zXib4Al0qn49TX-qM7PUkWUIcYtsgt36rjM,45
+geoseeq-0.7.2.dist-info/licenses/LICENSE,sha256=IuhIl1XCxXLPLJT_coN1CNqQU4Khlq7x4IdW7ioOJD8,1067
+geoseeq-0.7.2.dist-info/RECORD,,

{geoseeq-0.7.0.dist-info → geoseeq-0.7.2.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

geoseeq-0.7.0.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-geoseeq
-tests

tests/test_api_client.py

@@ -1,283 +0,0 @@
-"""Test suite for experimental functions."""
-import random
-import sys
-from os import environ
-from unittest import TestCase, skip
-
-from geoseeq import (
-    Knex,
-    Organization,
-    GeoseeqOtherError,
-    GeoseeqNotFoundError,
-)
-from requests.exceptions import ConnectionError
-
-ENDPOINT = environ.get("GEOSEEQ_API_TESTING_ENDPOINT", "http://127.0.0.1:8000")
-TOKEN = environ.get("GEOSEEQ_API_TOKEN", "<no_token>")
-
-
-def random_str(len=12):
-    """Return a random alphanumeric string of length `len`."""
-    out = random.choices("abcdefghijklmnopqrtuvwxyzABCDEFGHIJKLMNOPQRTUVWXYZ0123456789", k=len)
-    return "".join(out)
-
-
-class TestGeoseeqApiClient(TestCase):
-    """Test suite for packet building."""
-
-    def setUp(self):
-        self.knex = Knex(ENDPOINT)
-        # Creates a test user and an API token for the user in database. Returns the token.
-        if TOKEN == "<no_token>":
-            try:
-                api_token = self.knex.post("/users/test-user",
-                                           json={"email": f"clitestuser_{random_str()}@gmail.com"})
-            except GeoseeqOtherError:
-                print(f"Could not create test user on \"{ENDPOINT}\". If you are running this test suite "\
-                      "against a live server, please set the GEOSEEQ_API_TOKEN environment variable to a "\
-                      "valid API token.",
-                      file=sys.stderr)
-                raise
-            except ConnectionError:
-                print(f"Could not connect to GeoSeeq Server at \"{ENDPOINT}\".",
-                      file=sys.stderr)
-                raise
-            self.knex.add_api_token(api_token)
-        else:
-            self.knex.add_api_token(TOKEN)
-            try:
-                me = self.knex.get("/users/me")  # Test that the token is valid
-                self.username = me["name"]
-                self.org_name = f"API_TEST_ORG 1 {self.username}"
-            except GeoseeqNotFoundError:
-                print(f"Could not connect to GeoSeeq Server at \"{ENDPOINT}\" with the provided token.  "\
-                      "Is it possible that you set thd testing endpoint to a front end url instead of "\
-                      "the corresponding backend url?",
-                      file=sys.stderr)
-                raise
-
-    def test_create_org(self):
-        """Test that we can create an org."""
-        org = Organization(self.knex, self.org_name)
-        org.idem()
-        self.assertTrue(org.uuid)
-
-
-    def test_create_project(self):
-        """Test that we can create a project."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-
-        proj = org.project(f"my_client_test_project {key}")
-        proj.create()
-        self.assertTrue(org.uuid)
-        self.assertTrue(proj.uuid)
-
-    def test_create_project_result_folder(self):
-        """Test that we can create a result folder in a project."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        # N.B. It should NOT be necessary to call <parent>.create()
-        result_folder = proj.result_folder(f"my_client_test_module_name")  # no {key} necessary
-        result_folder.create()
-        self.assertTrue(org.uuid)
-        self.assertTrue(proj.uuid)
-        self.assertTrue(result_folder.uuid)
-
-    def test_create_project_result_file(self):
-        """Test that we can create a result file in a project."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        result_folder = proj.result_folder(f"my_client_test_module_name")  # no {key} necessary
-        # N.B. It should NOT be necessary to call <parent>.create()
-        result_file = result_folder.result_file("my_client_test_field_name", {"foo": "bar"})
-        result_file.create()
-        self.assertTrue(org.uuid)
-        self.assertTrue(proj.uuid)
-        self.assertTrue(result_folder.uuid)
-        self.assertTrue(result_file.uuid)
-
-    def test_create_sample(self):
-        """Test that we can create a sample."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        # N.B. It should NOT be necessary to call <parent>.create()
-        samp = proj.sample(f"my_client_test_sample {key}")
-        samp.create()
-        self.assertTrue(org.uuid)
-        self.assertTrue(proj.uuid)
-        self.assertTrue(samp.uuid)
-
-    def test_add_sample(self):
-        """Test that we can create a sample and add it to a different project."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj1 = org.project(f"my_client_test_proj1 {key}")
-        samp = proj1.sample(f"my_client_test_sample {key}").create()
-
-        proj2 = org.project(f"my_client_test_proj2 {key}").create()
-        proj2.add_sample(samp).save()
-        self.assertIn(samp.uuid, {samp.uuid for samp in proj2.get_samples()})
-
-    def test_get_samples_project(self):
-        """Test that we can get the samples in a project."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        samp_names = [f"my_client_test_sample_{i} {key}" for i in range(10)]
-        for samp_name in samp_names:
-            proj.sample(samp_name).create()
-        retrieved_proj = org.project(f"my_client_test_proj {key}").get()
-        retrieved_names = set()
-        for samp in retrieved_proj.get_samples():
-            retrieved_names.add(samp.name)
-            self.assertTrue(samp.uuid)
-        for samp_name in samp_names:
-            self.assertIn(samp_name, retrieved_names)
-
-    def test_get_result_folders_in_project(self):
-        """Test that we can get the result folders in a project."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        result_names = [("my_client_test_module", f"replicate_{i}") for i in range(10)]
-        for module_name, replicate in result_names:
-            proj.result_folder(module_name, replicate=replicate).create()
-        retrieved_proj = org.project(f"my_client_test_proj {key}").get()
-        retrieved_names = set()
-        for result in retrieved_proj.get_result_folders():
-            retrieved_names.add((result.module_name, result.replicate))
-            self.assertTrue(result.uuid)
-        for result_name_rep in result_names:
-            self.assertIn(result_name_rep, retrieved_names)
-
-    def test_get_result_folders_in_sample(self):
-        """Test that we can get the result folders in a sample."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        samp = proj.sample(f"my_client_test_sample {key}").create()
-        result_names = [("my_client_test_module", f"replicate_{i}") for i in range(10)]
-        for module_name, replicate in result_names:
-            samp.result_folder(module_name, replicate=replicate).create()
-        retrieved = proj.sample(f"my_client_test_sample {key}").get()
-        retrieved_names = set()
-        for result in retrieved.get_result_folders():
-            retrieved_names.add((result.module_name, result.replicate))
-            self.assertTrue(result.uuid)
-        for result_name_rep in result_names:
-            self.assertIn(result_name_rep, retrieved_names)
-
-    def test_get_result_files(self):
-        """Test that we can get the files in a result folder."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        samp = proj.sample(f"my_client_test_sample {key}")
-        result_folder = samp.result_folder("my_client_test_module").create()
-        self.assertTrue(proj.uuid)
-
-        field_names = [f"field_{i}" for i in range(10)]
-        for field_name in field_names:
-            result_folder.field(field_name).create()
-
-        retrieved = samp.result_folder("my_client_test_module").get()
-        retrieved_names = set()
-        for result in retrieved.get_fields():
-            retrieved_names.add(result.name)
-            self.assertTrue(result.uuid)
-        for result_name_rep in field_names:
-            self.assertIn(result_name_rep, retrieved_names)
-
-    def test_modify_sample(self):
-        """Test that we can modify a sample after creation"""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        # N.B. It should NOT be necessary to call <parent>.create()
-        samp = proj.sample(f"my_client_test_sample {key}")
-        samp.create()
-        self.assertTrue(samp.uuid)
-        self.assertTrue(samp._already_fetched)
-        self.assertFalse(samp._modified)
-        samp.metadata = {f"metadata_{key}": "some_new_metadata"}
-        self.assertTrue(samp._modified)
-        samp.save()
-        self.assertTrue(samp._already_fetched)
-        self.assertFalse(samp._modified)
-        retrieved = proj.sample(f"my_client_test_sample {key}").get()
-        self.assertIn(f"metadata_{key}", retrieved.metadata)
-
-    def test_create_sample_result_folder(self):
-        """Test that we can create a result folder in a sample."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        samp = proj.sample(f"my_client_test_sample {key}")
-        # N.B. It should NOT be necessary to call <parent>.create()
-        result_folder = samp.result_folder(f"my_client_test_module_name")  # no {key} necessary
-        result_folder.create()
-        self.assertTrue(org.uuid)
-        self.assertTrue(proj.uuid)
-        self.assertTrue(samp.uuid)
-        self.assertTrue(result_folder.uuid)
-
-    def test_create_sample_result_file(self):
-        """Test that we can create a result file in a sample."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        samp = proj.sample(f"my_client_test_sample {key}")
-        result_folder = samp.result_folder(f"my_client_test_module_name")  # no {key} necessary
-        # N.B. It should NOT be necessary to call <parent>.create()
-        result_file = result_folder.result_file("my_client_test_field_name", {"foo": "bar"})
-        result_file.create()
-        self.assertTrue(org.uuid)
-        self.assertTrue(proj.uuid)
-        self.assertTrue(samp.uuid)
-        self.assertTrue(result_folder.uuid)
-        self.assertTrue(result_file.uuid)
-
-    @skip("failing on server (2023-10-24)")
-    def test_modify_sample_result_file(self):
-        """Test that we can modify a result file in a sample."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        samp = proj.sample(f"my_client_test_sample {key}")
-        result_folder = samp.result_folder(f"my_client_test_module_name")  # no {key} necessary
-        # N.B. It should NOT be necessary to call <parent>.create()
-        result_file = result_folder.result_file(f"my_client_test_file_name {key}", {"foo": "bar"})
-        result_file.create()
-        self.assertTrue(result_file.uuid)
-        result_file.stored_data = {"foo": "bizz"}  # TODO: handle deep modifications
-        result_file.save()
-        retrieved = result_folder.result_file(f"my_client_test_file_name {key}").get()
-        self.assertEqual(retrieved.stored_data["foo"], "bizz")
-
-    def test_get_project_manifest(self):
-        """Test that we can get a project manifest."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        samp = proj.sample(f"my_client_test_sample {key}")
-        result_folder = samp.result_folder(f"my_client_test_module_name")  # no {key} necessary
-        result_file = result_folder.result_file("my_client_test_field_name", {"foo": "bar"})
-        result_file.create()
-        manifest = proj.get_manifest()
-        self.assertTrue(manifest)
-
-    def test_get_sample_manifest(self):
-        """Test that we can get a sample manifest."""
-        key = random_str()
-        org = Organization(self.knex, self.org_name)
-        proj = org.project(f"my_client_test_proj {key}")
-        samp = proj.sample(f"my_client_test_sample {key}")
-        result_folder = samp.result_folder(f"my_client_test_module_name")  # no {key} necessary
-        result_file = result_folder.result_file("my_client_test_field_name", {"foo": "bar"})
-        result_file.create()
-        manifest = samp.get_manifest()
-        self.assertTrue(manifest)

tests/test_plotting.py

@@ -1,29 +0,0 @@
-"""Test suite for plotting library."""
-import random
-from os import environ
-from os.path import dirname, join
-from unittest import TestCase, skip
-
-from geoseeq.plotting.map import Map
-
-
-class TestGeoseeqPlotting(TestCase):
-    """Test suite for packet building."""
-
-    def test_make_map_complex(self):
-        """Test that we can create a map and turn it into a dict."""
-        map = Map()\
-            .set_center(0, 0)\
-            .set_zoom(2)\
-            .add_light_base_map()\
-            .add_administrative_overlay()\
-            .add_places_overlay()
-        map.to_dict()
-
-    def test_make_map_simple(self):
-        """Test that we can create a map and turn it into a dict."""
-        map = Map()\
-            .add_light_base_map()
-        map.to_dict()
-        
-