geoseeq 0.6.14.dev7__tar.gz → 0.7.0__tar.gz

{geoseeq-0.6.14.dev7 → geoseeq-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: geoseeq
-Version: 0.6.14.dev7
+Version: 0.7.0
 Summary: GeoSeeq command line tools and python API
 Author: David C. Danko
 Author-email: "David C. Danko" <dcdanko@biotia.io>
@@ -18,6 +18,7 @@ Requires-Dist: pandas
 Requires-Dist: biopython
 Requires-Dist: tqdm
 Dynamic: author
+Dynamic: license-file
 
 # Geoseeq API Client
 

{geoseeq-0.6.14.dev7 → geoseeq-0.7.0}/geoseeq/cli/download.py

@@ -414,7 +414,7 @@ def _make_read_configs(download_results, config_dir="."):
         "reads_1": ["small.fq.gz"],
         "reads_2": [],
         "fastq_checksum": "",
-        "data_type": "short-read",
+        "data_type": "single",
         "bdx_result_dir": "results",
         "geoseeq_uuid": "05bf22e9-9d25-42db-af25-31bc538a7006"
     }
@@ -428,7 +428,7 @@ def _make_read_configs(download_results, config_dir="."):
                 "reads_1": [],
                 "reads_2": [],
                 "fastq_checksum": "",
-                "data_type": "short-read",
+                "data_type": read_type,
                 "bdx_result_dir": "results",
                 "geoseeq_uuid": sample.uuid,
             }

{geoseeq-0.6.14.dev7 → geoseeq-0.7.0}/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.6.14dev7')  # remember to update pyproject.toml
+    click.echo('0.7.0')  # remember to update pyproject.toml
 
 
 @main.group('advanced')

{geoseeq-0.6.14.dev7 → geoseeq-0.7.0}/geoseeq/cli/upload/__init__.py

@@ -4,9 +4,11 @@ from .upload import (
     cli_upload_file,
     cli_upload_folder,
     cli_metadata,
+    cli_upload_smart_table,
+    cli_upload_smart_tree,
 )
 from .upload_reads import cli_upload_reads_wizard
-from .upload_advanced import cli_find_urls_for_reads
+from .upload_advanced import cli_find_urls_for_reads, cli_upload_from_config
 
 @click.group('upload')
 def cli_upload():
@@ -17,10 +19,13 @@ cli_upload.add_command(cli_upload_reads_wizard)
 cli_upload.add_command(cli_upload_file)
 cli_upload.add_command(cli_upload_folder)
 cli_upload.add_command(cli_metadata)
+cli_upload.add_command(cli_upload_smart_table)
+cli_upload.add_command(cli_upload_smart_tree)
 
-@click.group('upload')
+@cli_upload.group('advanced')
 def cli_upload_advanced():
     """Advanced tools to upload files to GeoSeeq."""
     pass
 
-cli_upload_advanced.add_command(cli_find_urls_for_reads)
+cli_upload_advanced.add_command(cli_find_urls_for_reads)
+cli_upload_advanced.add_command(cli_upload_from_config)

{geoseeq-0.6.14.dev7 → geoseeq-0.7.0}/geoseeq/cli/upload/upload.py

@@ -263,3 +263,117 @@ def cli_metadata(state, overwrite, yes, private, create, index_col, encoding, pr
             sample.metadata = new_meta
             sample.idem()
     click.echo(f'Wrote metadata for {len(samples)} samples')
+
+
+@click.command('smart-table')
+@use_common_state
+@overwrite_option
+@yes_option
+@private_option
+@click.option('-n', '--geoseeq-file-name', default=None,
+              help='Specify a different name for the file on GeoSeeq than the local file name.',
+              show_default=True)
+@folder_id_arg
+@click.argument('file_path', type=click.Path(exists=True), nargs=1)
+def cli_upload_smart_table(state, overwrite, yes, private, folder_id, geoseeq_file_name, file_path):
+    """Upload a smart table to GeoSeeq.
+
+    This command uploads a smart table to a project or sample on GeoSeeq. It can be used to upload
+    a single file to a folder at once.
+    
+    ---
+
+    Example Usage:
+
+    \b
+    # Upload a smart table from a file
+    $ geoseeq upload smart-table "My Org/My Project/My Sample/My Folder" /path/to/my_table.csv
+
+    \b
+    # Upload a smart table from a file but name it "My Smart Table" on GeoSeeq
+    $ geoseeq upload smart-table "My Org/My Project/My Sample/My Folder" /path/to/my_table.csv -n "My Smart Table"
+
+    ---
+
+    Command Arguments:
+
+    [FOLDER_ID] Can be a folder UUID, GeoSeeq Resource Number (GRN), or an
+    names for an org, project, sample, folder separated by a slash. Can exclude
+    the sample name if the folder is for a project.
+
+    [FILE_PATH] A path to a file on your local machine.
+
+    ---
+    """
+    knex = state.get_knex()
+    result_folder = handle_folder_id(knex, folder_id, yes=yes, private=private)
+    
+    if not geoseeq_file_name:
+        geoseeq_file_name = basename(file_path)
+    
+    if not overwrite and result_folder.result_file(geoseeq_file_name).exists():
+        raise click.UsageError(f'{geoseeq_file_name} already exists in {result_folder}. Use --overwrite to overwrite it.')
+
+    result_file = result_folder.result_file(geoseeq_file_name)
+    smart_table = result_file.as_smart_table()
+    smart_table.import_csv(file_path)
+
+
+@click.command('smart-tree')
+@use_common_state
+@click.option('-m/-nm', '--make-name-map/--no-name-map', default=True, help="Create a sample name map with all samples currently in the project.")
+@overwrite_option
+@yes_option
+@private_option
+@click.option('-n', '--geoseeq-file-name', default=None,
+              help='Specify a different name for the file on GeoSeeq than the local file name.',
+              show_default=True)
+@folder_id_arg
+@click.argument('newick_file_path', type=click.Path(exists=True), nargs=1)
+def cli_upload_smart_tree(state, make_name_map, overwrite, yes, private, folder_id, geoseeq_file_name, newick_file_path):
+    """Upload a smart tree to GeoSeeq.
+
+    This command uploads a smart tree to a project or sample on GeoSeeq. It can be used to upload
+    a single file to a folder at once.
+    
+    ---
+
+    Example Usage:
+
+    \b
+    # Upload a smart tree from a file
+    $ geoseeq upload smart-tree "My Org/My Project/My Sample/My Folder" /path/to/my_tree.nwk
+
+    \b
+    # Upload a smart tree from a file but name it "My Smart Tree" on GeoSeeq
+    $ geoseeq upload smart-tree "My Org/My Project/My Sample/My Folder" /path/to/my_tree.nwk -n "My Smart Tree"
+
+    ---
+
+    Command Arguments:
+
+    [FOLDER_ID] Can be a folder UUID, GeoSeeq Resource Number (GRN), or an
+    names for an org, project, sample, folder separated by a slash. Can exclude
+    the sample name if the folder is for a project.
+
+    [NEWICK_FILE_PATH] A path to a newick file on your local machine.
+
+    ---
+    """
+    knex = state.get_knex()
+    result_folder = handle_folder_id(knex, folder_id, yes=yes, private=private)
+    
+    if not geoseeq_file_name:
+        geoseeq_file_name = basename(newick_file_path)
+    
+    if not overwrite and result_folder.result_file(geoseeq_file_name).exists():
+        raise click.UsageError(f'{geoseeq_file_name} already exists in {result_folder}. Use --overwrite to overwrite it.')
+
+    result_file = result_folder.result_file(geoseeq_file_name)
+    smart_tree = result_file.as_smart_tree()
+    with open(newick_file_path) as f:
+        newick_str = f.read()
+    smart_tree.create_from_newick(newick_str)
+    if make_name_map:
+        smart_tree.add_all_samples_to_map(result_folder.project)
+    smart_tree.idem()

geoseeq-0.7.0/geoseeq/cli/upload/upload_advanced.py

@@ -0,0 +1,322 @@
+import logging
+import click
+import requests
+from os.path import basename, getsize
+from .upload_reads import (
+    _make_in_process_logger,
+    _get_regex,
+    _group_files,
+    flatten_list_of_fastxs,
+)
+
+from multiprocessing import Pool, current_process
+
+from geoseeq.cli.constants import *
+from geoseeq.cli.shared_params import (
+    handle_project_id,
+    private_option,
+    module_option,
+    project_id_arg,
+    overwrite_option,
+    yes_option,
+    use_common_state,
+)
+
+from geoseeq.constants import FASTQ_MODULE_NAMES
+from geoseeq.cli.progress_bar import PBarManager
+import pandas as pd
+from typing import Dict, Optional
+from geoseeq.id_constructors.from_ids import (
+    org_from_id,
+    project_from_id,
+    sample_from_id,
+    result_folder_from_id,
+    result_file_from_id,
+)
+from geoseeq.upload_download_manager import GeoSeeqUploadManager
+
+logger = logging.getLogger('geoseeq_api')
+
+
+def _keep_only_authentication_url_args(url):
+    """Return a url with only the S3 authentication args"""
+    root, args = url.split('?')
+    args = args.split('&')
+    args = [arg for arg in args if arg.startswith('AWSAccessKeyId=') or arg.startswith('Signature=')]
+    return root + '?' + '&'.join(args)
+
+
+def _get_url_for_one_file(args):
+    """Return a tuple of the filepath and the url to upload it to"""
+    result_file, filepath, overwrite, log_level = args
+    _make_in_process_logger(log_level)
+    if result_file.exists() and not overwrite:  
+        return
+    result_file = result_file.idem()
+    file_size = getsize(filepath)
+    _, urls = result_file._prep_multipart_upload(filepath, file_size, file_size + 1, {})
+    url = _keep_only_authentication_url_args(urls['1'])
+    return filepath, url
+
+
+def _find_target_urls(groups, module_name, lib, filepaths, overwrite, cores, state):
+    """Use GeoSeeq to get target urls for a set of files"""
+    with requests.Session() as session:
+        find_url_args = []
+        for group in groups:
+            sample = lib.sample(group['sample_name']).idem()
+            read_folder = sample.result_folder(module_name).idem()
+
+            for field_name, path in group['fields'].items():
+                result_file = read_folder.read_file(field_name)
+                filepath = filepaths[path]
+                find_url_args.append((
+                    result_file, filepath, overwrite, state.log_level
+                ))
+
+        with Pool(cores) as p:
+            for (file_name, target_url) in p.imap_unordered(_get_url_for_one_file, find_url_args):
+                yield file_name, target_url
+
+
+@click.command('read-links')
+@use_common_state
+@click.option('--cores', default=1, help='Number of uploads to run in parallel')
+@overwrite_option
+@yes_option
+@click.option('--regex', default=None, help='An optional regex to use to extract sample names from the file names')
+@private_option
+@module_option(FASTQ_MODULE_NAMES)
+@project_id_arg
+@click.argument('fastq_files', type=click.Path(exists=True), nargs=-1)
+def cli_find_urls_for_reads(state, cores, overwrite, yes, regex, private, module_name, project_id, fastq_files):
+    """Print a two column list with filenames and a target storage URL
+    """
+    knex = state.get_knex()
+    proj = handle_project_id(knex, project_id, yes, private)
+    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)
+    for file_name, target_url in _find_target_urls(groups, module_name, proj, filepaths, overwrite, cores, state):
+        print(f'{file_name}\t{target_url}', file=state.outfile)
+
+
+def _get_result_file_from_record_with_ids(knex, record: Dict) -> Dict:
+    """Get all relevant objects from a record, handling GRNs, UUIDs, and absolute names without requiring parent objects.
+    
+    Returns a dict with 'org', 'project', 'sample', 'folder', and 'result_file' keys.
+    Objects may be None if not needed/specified.
+    Guaranteed that at least org is not None.
+    """
+    objects = {
+        'org': None,
+        'project': None,
+        'sample': None,
+        'folder': None,
+        'result_file': None
+    }
+
+    # Try to get file directly - if it's a GRN/UUID we don't need parent objects
+    try:
+        objects['result_file'] = result_file_from_id(knex, record['filename'])
+        objects['folder'] = objects['result_file'].folder
+        if hasattr(objects['folder'], 'sample'):
+            objects['sample'] = objects['folder'].sample
+            objects['project'] = objects['sample'].project
+        else:
+            objects['project'] = objects['folder'].project
+        objects['org'] = objects['project'].org
+        return objects
+    except ValueError:
+        pass  # Not a GRN, UUID or abs name. Continue with normal flow
+
+    # Try to get folder directly - if it's a GRN/UUID we don't need parent objects
+    try:
+        objects['folder'] = result_folder_from_id(knex, record['folder'])
+        # Get parent objects from folder
+        if hasattr(objects['folder'], 'sample'):
+            objects['sample'] = objects['folder'].sample
+            objects['project'] = objects['sample'].project
+        else:
+            objects['project'] = objects['folder'].project
+        objects['org'] = objects['project'].org
+        return objects
+    except ValueError:
+        pass  # Not a GRN, UUID or abs name. Continue with normal flow
+
+    # Try to get sample directly if specified
+    if pd.notna(record['sample']):
+        try:
+            objects['sample'] = sample_from_id(knex, record['sample'])
+            objects['project'] = objects['sample'].project
+            objects['org'] = objects['project'].org
+            return objects
+        except ValueError:
+            pass  # Not a GRN, UUID or abs name. Continue with normal flow
+
+    # Try to get project directly
+    try:
+        objects['project'] = project_from_id(knex, record['project'])
+        objects['org'] = objects['project'].org
+        return objects
+    except ValueError:
+        pass  # Not a GRN/UUID, continue
+
+    
+    if objects['org'] is None: # Get org directly if we don't have one yet
+        objects['org'] = org_from_id(knex, record['organization'])
+    
+    return objects
+
+
+def _get_result_file_from_record(knex, record: Dict) -> Dict:
+    """Get all relevant objects from a record, handling GRNs/UUIDs without requiring parent objects.
+    
+    Returns a dict with 'org', 'project', 'sample', 'folder', and 'result_file' keys.
+    Objects may be None if not needed/specified.
+    """
+    objects = _get_result_file_from_record_with_ids(knex, record)
+
+    if objects['project'] is None:
+        objects['project'] = objects['org'].project(record['project'])
+
+    if objects['sample'] is None:
+        if pd.notna(record['sample']):
+            objects['sample'] = objects['project'].sample(record['sample'])
+            parent = objects['sample']
+    else:
+        parent = objects['project']
+
+    if objects['folder'] is None:
+        objects['folder'] = parent.result_folder(record['folder'])
+
+    if objects['result_file'] is None:
+        objects['result_file'] = objects['folder'].result_file(record['filename'])
+
+    objects['result_file'].idem()
+    print(objects)
+    return objects
+
+
+def _add_record_to_upload_manager_local_file(record: Dict, result_file, upload_manager: GeoSeeqUploadManager) -> None:
+    """Add a local file upload to the upload manager."""
+    upload_manager.add_result_file(result_file, record['path'], link_type='upload')
+
+
+def _add_record_to_upload_manager_s3_file(record: Dict, result_file, upload_manager: GeoSeeqUploadManager) -> None:
+    """Add an S3 file link to the upload manager.
+    
+    Handles two types of S3 URLs:
+    1. https://endpoint/bucket/key - Full URL with endpoint included
+    2. s3://bucket/key - S3 protocol URL that needs endpoint added
+    """
+    path = record['path']
+    
+    if path.startswith('s3://'):
+        # Convert s3:// URL to https:// URL
+        if not record['endpoint_url']:
+            raise ValueError("endpoint_url is required for s3:// URLs")
+        
+        # Remove s3:// prefix and combine with endpoint
+        bucket_and_key = path[5:]  # len('s3://') == 5
+        path = f"{record['endpoint_url'].rstrip('/')}/{bucket_and_key}"
+    elif not path.startswith('https://'):
+        raise ValueError("S3 URLs must start with either 's3://' or 'https://'")
+
+    upload_manager.add_result_file(result_file, path, link_type='s3')
+
+
+def _upload_one_record(knex, record: Dict, overwrite: bool, upload_manager: GeoSeeqUploadManager) -> Dict:
+    """Process a single record from the config file and add it to the upload manager."""
+    objects = _get_result_file_from_record(knex, record)
+    if not objects['result_file']:
+        raise ValueError(f"Could not find or create result_file from record: {record}")
+
+    # Add to upload manager based on type
+    if record['type'].lower() == 'local':
+        _add_record_to_upload_manager_local_file(record, objects["result_file"], upload_manager)
+    elif record['type'].lower() == 's3':
+        _add_record_to_upload_manager_s3_file(record, objects["result_file"], upload_manager)
+    else:
+        raise ValueError(f"Unknown file type: {record['type']}")
+
+    return objects
+
+
+REQUIRED_COLUMNS = [
+    'organization', 'project', 'sample', 'folder', 
+    'filename', 'path', 'type', 'endpoint_url'
+]
+
+
+@click.command('from-config')
+@use_common_state
+@click.option('--cores', default=1, help='Number of uploads to run in parallel')
+@click.option('--sep', default=',', help='Separator character for the CSV file')
+@overwrite_option
+@yes_option
+@click.argument('config_file', type=click.Path(exists=True))
+def cli_upload_from_config(state, cores, sep, overwrite, yes, config_file):
+    """Upload files to GeoSeeq based on a configuration CSV file.
+
+    \b
+    The CSV file must have the following columns:
+    - organization: Organization name, GRN, or UUID (optional if project/sample/folder specified by GRN/UUID)
+    - project: Project name, GRN, or UUID (optional if sample/folder specified by GRN/UUID)
+    - sample: Sample name, GRN, or UUID (optional, also optional if folder specified by GRN/UUID)
+    - folder: Folder name, GRN, or UUID
+    - filename: Name to give the file on GeoSeeq
+    - path: Path to local file or S3 URL
+    - type: Either "local" or "s3"
+    - endpoint_url: S3 endpoint URL (required for S3 files)
+
+    \b
+    When using GRNs or UUIDs, you can omit the parent object IDs. For example:
+    - If folder is a GRN/UUID, organization/project/sample can be blank
+    - If sample is a GRN/UUID, organization/project can be blank
+    - If project is a GRN/UUID, organization can be blank
+
+    \b
+    Example config.csv:
+    organization,project,sample,folder,filename,path,type,endpoint_url
+    MyOrg,MyProject,Sample1,reads,file1.fastq,/path/to/file1.fastq,local,
+    ,grn:project:uuid,Sample2,reads,file2.fastq,/path/to/file2.fastq,local,
+    ,,grn:sample:uuid,reads,file3.fastq,/path/to/file3.fastq,local,
+    ,,,grn:folder:uuid,file4.fastq,s3://bucket/file4.fastq,s3,https://s3.amazonaws.com
+
+    \b
+    Example with tab separator:
+    $ geoseeq upload advanced from-config --sep $'\t' config.tsv
+    """
+    knex = state.get_knex()
+    
+    # Read and validate config file
+    df = pd.read_csv(config_file, sep=sep)
+    missing_cols = set(REQUIRED_COLUMNS) - set(df.columns)
+    if missing_cols:
+        raise click.UsageError(f"Config file missing required columns: {missing_cols}")
+    
+    # Create upload manager
+    upload_manager = GeoSeeqUploadManager(
+        n_parallel_uploads=cores,
+        progress_tracker_factory=PBarManager().get_new_bar,
+        log_level=state.log_level,
+        overwrite=overwrite,
+        use_cache=state.use_cache,
+    )
+    
+    # Process records and add to upload manager
+    objects_by_record = {}  # Store objects for human readable paths
+    for _, record in df.iterrows():
+        objects = _upload_one_record(knex, record, overwrite, upload_manager)
+        objects_by_record[record['path']] = objects
+    
+    # Show preview with both technical and human readable paths
+    click.echo(upload_manager.get_preview_string(), err=True)
+    
+    if not yes:
+        click.confirm('Do you want to proceed with these uploads?', abort=True)
+    
+    # Perform uploads
+    upload_manager.upload_files()

{geoseeq-0.6.14.dev7 → geoseeq-0.7.0}/geoseeq/cli/upload/upload_reads.py

@@ -2,7 +2,7 @@ import logging
 import click
 import requests
 from os.path import basename
-
+import pandas as pd
 from multiprocessing import Pool, current_process
 
 from geoseeq.cli.constants import *
@@ -67,8 +67,12 @@ def _get_regex(knex, filepaths, module_name, lib, regex):
     return regex
 
 
-def _group_files(knex, filepaths, module_name, regex, yes):
+def _group_files(knex, filepaths, module_name, regex, yes, name_map):
     """Group the files into samples, confirm, and return the groups."""
+    if name_map is not None:
+        name_map_filename, cur_col, new_col = name_map
+        name_map = pd.read_csv(name_map_filename)[[cur_col, new_col]]
+        name_map = name_map.set_index(cur_col).to_dict()
     seq_length, seq_type = module_name.split('::')[:2]
     groups = knex.post('bulk_upload/group_files', json={
         'filenames': list(filepaths.keys()),
@@ -76,7 +80,11 @@ def _group_files(knex, filepaths, module_name, regex, yes):
         'regex': regex
     })
     for group in groups:
-        click.echo(f'sample_name: {group["sample_name"]}', err=True)
+        sample_name = group["sample_name"]
+        if name_map:
+            sample_name = name_map.get(sample_name, sample_name)
+            group["sample_name"] = sample_name
+        click.echo(f'sample_name: {sample_name}', err=True)
         click.echo(f'  module_name: {module_name}', err=True)
         for field_name, filename in group['fields'].items():
             path = filepaths[filename]
@@ -173,10 +181,11 @@ def flatten_list_of_bams(filepaths):
 @private_option
 @link_option
 @no_new_versions_option
+@click.option('--name-map', default=None, nargs=3, help="A file to use for converting names. Takes three arguments: a file name, a column name for current names, and a column name for new names.")
 @module_option(FASTQ_MODULE_NAMES)
 @project_id_arg
 @click.argument('fastq_files', type=click.Path(exists=True), nargs=-1)
-def cli_upload_reads_wizard(state, cores, overwrite, yes, regex, private, link_type, no_new_versions, module_name, project_id, fastq_files):
+def cli_upload_reads_wizard(state, cores, overwrite, yes, regex, private, link_type, no_new_versions, name_map, module_name, project_id, fastq_files):
     """Upload fastq read files to GeoSeeq.
 
     This command automatically groups files by their sample name, lane number

{geoseeq-0.6.14.dev7 → geoseeq-0.7.0}/geoseeq/constants.py

@@ -1,5 +1,6 @@
 from os import environ
 from os.path import join
+from typing import Literal
 
 FIVE_MB = 5 * (1024 ** 2)
 FASTQ_MODULE_NAMES = [
@@ -13,4 +14,6 @@ DEFAULT_ENDPOINT = "https://backend.geoseeq.com"
 
 CONFIG_FOLDER = environ.get("XDG_CONFIG_HOME", join(environ["HOME"], ".config"))
 CONFIG_DIR = environ.get("GEOSEEQ_CONFIG_DIR", join(CONFIG_FOLDER, "geoseeq"))
-PROFILES_PATH = join(CONFIG_DIR, "profiles.json")
+PROFILES_PATH = join(CONFIG_DIR, "profiles.json")
+
+OBJECT_TYPE_STR = Literal['org', 'project', 'sample', 'sample_result_folder', 'project_result_folder', 'sample_result_file', 'project_result_file']

{geoseeq-0.6.14.dev7 → geoseeq-0.7.0}/geoseeq/id_constructors/from_ids.py

@@ -22,51 +22,51 @@ from .from_names import (
     project_result_file_from_name,
     result_file_from_name,
 )
-from .utils import is_grn_or_uuid, is_name
+from .utils import is_grn_or_uuid, is_name, is_abs_name
 from geoseeq.knex import with_knex
-
+from geoseeq.constants import OBJECT_TYPE_STR
 logger = logging.getLogger("geoseeq_api")  # Same name as calling module
 
 
-def _generic_from_id(knex, id, from_uuid_func, from_name_func):
+def _generic_from_id(knex, id, from_uuid_func, from_name_func, object_type_str: OBJECT_TYPE_STR):
     """Return the object which the id points to."""
     logger.debug(f'Getting object from id: {id}, knex: {knex}, from_uuid_func: {from_uuid_func}, from_name_func: {from_name_func}')
     if is_grn_or_uuid(id):
         id = id.split(':')[-1]  # if this is a GRN, get the UUID. Won't hurt if it's already a UUID.
         return from_uuid_func(knex, id)
-    if is_name(id):
+    if is_abs_name(id, object_type_str):
         return from_name_func(knex, id)
-    raise ValueError(f'"{id}" is not a GRN, UUID, or name')
+    raise ValueError(f'"{id}" is not a GRN, UUID, or absolute name for {object_type_str}')
 
 
 @with_knex
 def org_from_id(knex, id):
     """Return the organization object which the id points to."""
-    return _generic_from_id(knex, id, org_from_uuid, org_from_name)
+    return _generic_from_id(knex, id, org_from_uuid, org_from_name, 'org')
 
 
 @with_knex
 def project_from_id(knex, id):
     """Return the project object which the id points to."""
-    return _generic_from_id(knex, id, project_from_uuid, project_from_name)
+    return _generic_from_id(knex, id, project_from_uuid, project_from_name, 'project')
 
 
 @with_knex
 def sample_from_id(knex, id):
     """Return the sample object which the id points to."""
-    return _generic_from_id(knex, id, sample_from_uuid, sample_from_name)
+    return _generic_from_id(knex, id, sample_from_uuid, sample_from_name, 'sample')
 
 
 @with_knex
 def sample_result_folder_from_id(knex, id):
     """Return the sample result folder object which the id points to."""
-    return _generic_from_id(knex, id, sample_result_folder_from_uuid, sample_result_folder_from_name)
+    return _generic_from_id(knex, id, sample_result_folder_from_uuid, sample_result_folder_from_name, 'sample_result_folder')
 
 
 @with_knex
 def project_result_folder_from_id(knex, id):
     """Return the project result folder object which the id points to."""
-    return _generic_from_id(knex, id, project_result_folder_from_uuid, project_result_folder_from_name)
+    return _generic_from_id(knex, id, project_result_folder_from_uuid, project_result_folder_from_name, 'project_result_folder')
 
 
 @with_knex
@@ -75,19 +75,22 @@ def result_folder_from_id(knex, id):
     
     Guess the result folder is a sample result folder. If not, try a project result folder.
     """
-    return _generic_from_id(knex, id, result_folder_from_uuid, result_folder_from_name)
+    try:
+        return _generic_from_id(knex, id, result_folder_from_uuid, result_folder_from_name, 'sample_result_folder')
+    except ValueError:
+        return _generic_from_id(knex, id, result_folder_from_uuid, result_folder_from_name, 'project_result_folder')
 
 
 @with_knex
 def sample_result_file_from_id(knex, id):
     """Return the sample result file object which the id points to."""
-    return _generic_from_id(knex, id, sample_result_file_from_uuid, sample_result_file_from_name)
+    return _generic_from_id(knex, id, sample_result_file_from_uuid, sample_result_file_from_name, 'sample_result_file')
 
 
 @with_knex
 def project_result_file_from_id(knex, id):
     """Return the project result file object which the id points to."""
-    return _generic_from_id(knex, id, project_result_file_from_uuid, project_result_file_from_name)
+    return _generic_from_id(knex, id, project_result_file_from_uuid, project_result_file_from_name, 'project_result_file')
 
 
 @with_knex
@@ -96,7 +99,10 @@ def result_file_from_id(knex, id):
     
     Guess the result file is a sample result file. If not, try a project result file.
     """
-    return _generic_from_id(knex, id, result_file_from_uuid, result_file_from_name)
+    try:
+        return _generic_from_id(knex, id, result_file_from_uuid, result_file_from_name, 'sample_result_file')
+    except ValueError:
+        return _generic_from_id(knex, id, result_file_from_uuid, result_file_from_name, 'project_result_file')