deriva-ml 1.10.1__py3-none-any.whl → 1.11.0__py3-none-any.whl

deriva_ml/dataset.py

@@ -805,7 +805,7 @@ class Dataset:
             dataset_elements = [
                 snapshot_catalog._model.name_to_table(e)
                 for e, m in snapshot_catalog.list_dataset_members(
-                    dataset_rid=dataset_rid, limit=1
+                    dataset_rid=dataset_rid,  #  limit=1  Limit seems to make things run slow.
                 ).items()
                 if m
             ]

deriva_ml/dataset_bag.py

@@ -168,7 +168,7 @@ class DatasetBag:
                 yield dict(zip(col_names, row))
 
     @validate_call
-    def list_dataset_members(self, recurse: bool = False) -> dict[str, list[tuple]]:
+    def list_dataset_members(self, recurse: bool = False) -> dict[str, dict[str, Any]]:
         """Return a list of entities associated with a specific _dataset_table.
 
         Args:
@@ -206,12 +206,19 @@ class DatasetBag:
             )
 
             with self.database as db:
+                col_names = [
+                    c[1]
+                    for c in db.execute(f'PRAGMA table_info("{sql_target}")').fetchall()
+                ]
+                select_cols = ",".join([f'"{sql_target}".{c}' for c in col_names])
                 sql_cmd = (
-                    f'SELECT * FROM "{sql_member}" '
+                    f'SELECT {select_cols} FROM "{sql_member}" '
                     f'JOIN "{sql_target}" ON "{sql_member}".{member_link[0]} = "{sql_target}".{member_link[1]} '
                     f'WHERE "{self.dataset_rid}" = "{sql_member}".Dataset;'
                 )
-                target_entities = db.execute(sql_cmd).fetchall()
+                target_entities = [
+                    dict(zip(col_names, e)) for e in db.execute(sql_cmd).fetchall()
+                ]
                 members[target_table.name].extend(target_entities)
 
             target_entities = []  # path.entities().fetch()

deriva_ml/demo_catalog.py

@@ -2,9 +2,7 @@ import atexit
 from importlib.metadata import version
 from importlib.resources import files
 import logging
-from random import random, randint
-import tempfile
-from tempfile import TemporaryDirectory
+from random import randint, random
 from typing import Optional
 import itertools
 
@@ -12,7 +10,6 @@ from deriva.config.acl_config import AclConfig
 from deriva.core import DerivaServer
 from deriva.core import ErmrestCatalog, get_credential
 from deriva.core.datapath import DataPathException
-from deriva.core.ermrest_model import Model
 from deriva.core.ermrest_model import builtin_types, Schema, Table, Column
 from requests import HTTPError
 
@@ -35,48 +32,51 @@ TEST_DATASET_SIZE = 4
 def reset_demo_catalog(deriva_ml: DerivaML, sname: str):
     model = deriva_ml.model
     for trial in range(3):
-        for t in [
-            v
-            for v in model.schemas[sname].tables.values()
-            if v.name not in {"Subject", "Image"}
-        ]:
+        for t in [v for v in model.schemas[sname].tables.values()]:
             try:
                 t.drop()
             except HTTPError:
                 pass
-
+    model.schemas[sname].drop()
     # Empty out remaining tables.
     pb = deriva_ml.pathBuilder
     retry = True
     while retry:
-        retry = False
-        for s in [sname, "deriva-ml"]:
-            for t in pb.schemas[s].tables.values():
-                for e in t.entities().fetch():
-                    try:
-                        t.filter(t.RID == e["RID"]).delete()
-                    except DataPathException:  # FK constraint.
-                        retry = True
-
+        for t in pb.schemas["deriva-ml"].tables.values():
+            for e in t.entities().fetch():
+                try:
+                    t.filter(t.RID == e["RID"]).delete()
+                except DataPathException:  # FK constraint.
+                    retry = True
     initialize_ml_schema(model, "deriva-ml")
+    create_domain_schema(deriva_ml, sname)
 
 
 def populate_demo_catalog(deriva_ml: DerivaML, sname: str) -> None:
     # Delete any vocabularies and features.
-    reset_demo_catalog(deriva_ml, sname)
     domain_schema = deriva_ml.catalog.getPathBuilder().schemas[sname]
     subject = domain_schema.tables["Subject"]
     ss = subject.insert([{"Name": f"Thing{t + 1}"} for t in range(TEST_DATASET_SIZE)])
-
-    with TemporaryDirectory() as tmpdir:
-        image_dir = deriva_ml.asset_dir("Image", prefix=tmpdir)
+    deriva_ml.add_term(
+        MLVocab.workflow_type,
+        "Demo Catalog Creation",
+        description="A workflow demonstrating how to create a demo catalog.",
+    )
+    execution = deriva_ml.create_execution(
+        ExecutionConfiguration(
+            workflow=deriva_ml.create_workflow(
+                name="Demo Catalog", workflow_type="Demo Catalog Creation"
+            )
+        )
+    )
+    with execution.execute() as e:
         for s in ss:
-            image_file = image_dir.create_file(
-                f"test_{s['RID']}.txt", {"Subject": s["RID"]}
+            image_file = e.asset_file_path(
+                "Image", f"test_{s['RID']}.txt", Subject=s["RID"]
             )
             with open(image_file, "w") as f:
                 f.write(f"Hello there {random()}\n")
-        deriva_ml.upload_assets(image_dir)
+        execution.upload_execution_outputs()
 
 
 def create_demo_datasets(ml_instance: DerivaML) -> tuple[RID, list[RID], list[RID]]:
@@ -84,6 +84,13 @@ def create_demo_datasets(ml_instance: DerivaML) -> tuple[RID, list[RID], list[RI
     ml_instance.add_dataset_element_type("Image")
 
     type_rid = ml_instance.add_term("Dataset_Type", "TestSet", description="A test")
+    training_rid = ml_instance.add_term(
+        "Dataset_Type", "Training", description="A traing set"
+    )
+    testing_rid = ml_instance.add_term(
+        "Dataset_Type", "Testing", description="A testing set"
+    )
+
     table_path = (
         ml_instance.catalog.getPathBuilder()
         .schemas[ml_instance.domain_schema]
@@ -94,7 +101,7 @@ def create_demo_datasets(ml_instance: DerivaML) -> tuple[RID, list[RID], list[RI
     dataset_rids = []
     for r in subject_rids[0:4]:
         d = ml_instance.create_dataset(
-            type_rid.name,
+            type=[type_rid.name, "Testing"],
             description=f"Dataset {r}",
             version=DatasetVersion(1, 0, 0),
         )
@@ -104,7 +111,7 @@ def create_demo_datasets(ml_instance: DerivaML) -> tuple[RID, list[RID], list[RI
     nested_datasets = []
     for i in range(0, 4, 2):
         nested_dataset = ml_instance.create_dataset(
-            type_rid.name,
+            type=[type_rid.name, "Training"],
             description=f"Nested Dataset {i}",
             version=DatasetVersion(1, 0, 0),
         )
@@ -132,13 +139,11 @@ def create_demo_features(ml_instance):
         "Well",
         description="The subject self reports that they feel well",
     )
-
     ml_instance.create_vocabulary(
         "ImageQuality", "Controlled vocabulary for image quality"
     )
     ml_instance.add_term("ImageQuality", "Good", description="The image is good")
     ml_instance.add_term("ImageQuality", "Bad", description="The image is bad")
-
     box_asset = ml_instance.create_asset(
         "BoundingBox", comment="A file that contains a cropped version of a image"
     )
@@ -150,7 +155,6 @@ def create_demo_features(ml_instance):
         metadata=[ColumnDefinition(name="Scale", type=BuiltinTypes.int2, nullok=True)],
         optional=["Scale"],
     )
-
     ml_instance.create_feature("Image", "BoundingBox", assets=[box_asset])
     ml_instance.create_feature("Image", "Quality", terms=["ImageQuality"])
 
@@ -158,78 +162,88 @@ def create_demo_features(ml_instance):
     ImageBoundingboxFeature = ml_instance.feature_record_class("Image", "BoundingBox")
     SubjectWellnessFeature = ml_instance.feature_record_class("Subject", "Health")
 
+    # Get the workflow for this notebook
+
     ml_instance.add_term(
         MLVocab.workflow_type,
-        "API Workflow",
+        "Feature Notebook Workflow",
         description="A Workflow that uses Deriva ML API",
     )
     ml_instance.add_term(
-        MLVocab.execution_asset_type,
-        "API_Model",
-        description="Model for our API workflow",
+        MLVocab.asset_type, "API_Model", description="Model for our Notebook workflow"
     )
-
-    api_workflow = ml_instance.create_workflow(
-        name="API Workflow",
-        workflow_type="API Workflow",
+    notebook_workflow = ml_instance.create_workflow(
+        name="API Workflow", workflow_type="Feature Notebook Workflow"
     )
 
-    api_execution = ml_instance.create_execution(
+    feature_execution = ml_instance.create_execution(
         ExecutionConfiguration(
-            workflow=api_workflow, description="Our Sample Workflow instance"
+            workflow=notebook_workflow, description="Our Sample Workflow instance"
         )
     )
 
-    with tempfile.TemporaryDirectory() as temp_dir:
-        assetdir = ml_instance.asset_dir("BoundingBox", prefix=temp_dir)
-        for i in range(10):
-            with open(assetdir.path / f"box{i}.txt", "w") as fp:
-                fp.write(f"Hi there {i}")
-        bounding_box_assets = ml_instance.upload_assets(assetdir)
-    bounding_box_rids = [a.result["RID"] for a in bounding_box_assets.values()]
-
-    # Get the IDs of al of the things that we are going to want to attach features to.
     subject_rids = [
         i["RID"] for i in ml_instance.domain_path.tables["Subject"].entities().fetch()
     ]
     image_rids = [
         i["RID"] for i in ml_instance.domain_path.tables["Image"].entities().fetch()
     ]
-
     subject_feature_list = [
         SubjectWellnessFeature(
             Subject=subject_rid,
-            Execution=api_execution.execution_rid,
+            Execution=feature_execution.execution_rid,
             SubjectHealth=["Well", "Sick"][randint(0, 1)],
             Scale=randint(1, 10),
         )
         for subject_rid in subject_rids
     ]
 
+    # Create a new set of images.  For fun, lets wrap this in an execution so we get status updates
+    bounding_box_files = []
+    for i in range(10):
+        bounding_box_file = feature_execution.asset_file_path(
+            "BoundingBox", f"box{i}.txt"
+        )
+        with open(bounding_box_file, "w") as fp:
+            fp.write(f"Hi there {i}")
+        bounding_box_files.append(bounding_box_file)
+
+    image_bounding_box_feature_list = [
+        ImageBoundingboxFeature(
+            Image=image_rid,
+            BoundingBox=asset_name,
+        )
+        for image_rid, asset_name in zip(
+            image_rids, itertools.cycle(bounding_box_files)
+        )
+    ]
+
     image_quality_feature_list = [
         ImageQualityFeature(
             Image=image_rid,
-            Execution=api_execution.execution_rid,
             ImageQuality=["Good", "Bad"][randint(0, 1)],
         )
         for image_rid in image_rids
     ]
 
-    image_bounding_box_feature_list = [
-        ImageBoundingboxFeature(
-            Image=image_rid,
-            Execution=api_execution.execution_rid,
-            BoundingBox=asset_rid,
+    subject_feature_list = [
+        SubjectWellnessFeature(
+            Subject=subject_rid,
+            SubjectHealth=["Well", "Sick"][randint(0, 1)],
+            Scale=randint(1, 10),
         )
-        for image_rid, asset_rid in zip(image_rids, itertools.cycle(bounding_box_rids))
+        for subject_rid in subject_rids
     ]
 
-    ml_instance.add_features(subject_feature_list)
-    ml_instance.add_features(image_quality_feature_list)
-    ml_instance.add_features(image_bounding_box_feature_list)
+    with feature_execution.execute() as execution:
+        feature_execution.add_features(image_bounding_box_feature_list)
+        feature_execution.add_features(image_quality_feature_list)
+        feature_execution.add_features(subject_feature_list)
+
+    feature_execution.upload_execution_outputs()
 
 
-def create_domain_schema(model: Model, sname: str) -> None:
+def create_domain_schema(ml_instance: DerivaML, sname: str) -> None:
     """
     Create a domain schema.  Assumes that the ml-schema has already been created.
     :param model:
@@ -238,28 +252,19 @@ def create_domain_schema(model: Model, sname: str) -> None:
     """
 
     # Make sure that we have a ml schema
-    _ = model.schemas["deriva-ml"]
+    _ = ml_instance.model.schemas["deriva-ml"]
 
-    if model.schemas.get(sname):
+    if ml_instance.model.schemas.get(sname):
         # Clean out any old junk....
-        model.schemas[sname].drop()
+        ml_instance.model.schemas[sname].drop()
 
-    domain_schema = model.create_schema(
+    domain_schema = ml_instance.model.model.create_schema(
         Schema.define(sname, annotations={"name_style": {"underline_space": True}})
     )
     subject_table = domain_schema.create_table(
         Table.define("Subject", column_defs=[Column.define("Name", builtin_types.text)])
     )
-
-    image_table = domain_schema.create_table(
-        Table.define_asset(
-            sname=sname,
-            tname="Image",
-            hatrac_template="/hatrac/image_asset/{{MD5}}.{{Filename}}",
-            column_defs=[Column.define("Name", builtin_types.text)],
-        )
-    )
-    image_table.create_reference(subject_table)
+    ml_instance.create_asset("Image", referenced_tables=[subject_table])
 
 
 def destroy_demo_catalog(catalog):
@@ -284,13 +289,14 @@ def create_demo_catalog(
 
     try:
         create_ml_schema(model, project_name=project_name)
-        create_domain_schema(model, domain_schema)
         deriva_ml = DerivaML(
             hostname=hostname,
             catalog_id=test_catalog.catalog_id,
             project_name=project_name,
+            domain_schema=domain_schema,
             logging_level=logging.WARN,
         )
+        create_domain_schema(deriva_ml, domain_schema)
         working_dir = deriva_ml.working_dir
         dataset_table = deriva_ml.dataset_table
         dataset_table.annotations.update(

deriva_ml/deriva_definitions.py

@@ -186,9 +186,9 @@ class MLVocab(StrEnum):
 
     dataset_type = "Dataset_Type"
     workflow_type = "Workflow_Type"
-    execution_asset_type = "Execution_Asset_Type"
-    execution_metadata_type = "Execution_Metadata_Type"
     file_type = "File_Type"
+    asset_type = "Asset_Type"
+    asset_role = "Asset_Role"
 
 
 class ExecMetadataVocab(StrEnum):

deriva_ml/deriva_ml_base.py

@@ -31,7 +31,6 @@ from deriva.core.datapath import DataPathException
 from deriva.core.deriva_server import DerivaServer
 from deriva.core.ermrest_catalog import ResolveRidResult
 from deriva.core.ermrest_model import Key, Table
-from deriva.core.hatrac_store import HatracStore
 from deriva.core.utils.globus_auth_utils import GlobusNativeLogin
 from pydantic import validate_call, ConfigDict
 from requests import RequestException
@@ -42,24 +41,17 @@ from .dataset import Dataset
 from .dataset_aux_classes import DatasetSpec
 from .dataset_bag import DatasetBag
 from .deriva_model import DerivaModel
-from .upload import (
-    table_path,
-    execution_rids,
-    execution_metadata_dir,
-    upload_directory,
-    UploadAssetDirectory,
-)
+from .upload import table_path, execution_rids, asset_file_path
 from .deriva_definitions import ColumnDefinition
-from .deriva_definitions import ExecMetadataVocab
 from .deriva_definitions import (
     RID,
     Status,
-    FileUploadState,
     DerivaMLException,
     ML_SCHEMA,
     VocabularyTerm,
     MLVocab,
     FileSpec,
+    TableDefinition,
 )
 
 try:
@@ -346,30 +338,6 @@ class DerivaML(Dataset):
             table=self.model.name_to_table(table).name,
         )
 
-    def asset_dir(
-        self, table: str | Table, prefix: Optional[str | Path] = None
-    ) -> UploadAssetDirectory:
-        """Return a local file path in which to place a files for an asset table.  T
-
-        Args:
-            table: Location of where to place files.  Defaults to execution_assets_path.
-            prefix: Root path to asset directory.
-
-        Returns:
-            Path to the directory in which asset files should be placed.
-        """
-        table = self.model.name_to_table(table)
-        if not self.model.is_asset(table):
-            raise DerivaMLException(f"The table {table} is not an asset table.")
-
-        prefix = Path(prefix) if prefix else self.working_dir
-        return UploadAssetDirectory(
-            model=self.model,
-            prefix=prefix,
-            schema=table.schema.name,
-            table=table.name,
-        )
-
     def download_dir(self, cached: bool = False) -> Path:
         """Location where downloaded files are placed.
 
@@ -532,10 +500,17 @@ class DerivaML(Dataset):
             )
         )
 
+    def create_table(self, table: TableDefinition) -> Table:
+        """Create a table from a table definition."""
+        return self.model.schemas[self.domain_schema].create_table(table.model_dump())
+
+    @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
     def create_asset(
         self,
         asset_name: str,
         column_defs: Optional[Iterable[ColumnDefinition]] = None,
+        fkey_defs: Optional[Iterable[ColumnDefinition]] = None,
+        referenced_tables: Optional[Iterable[Table]] = None,
         comment: str = "",
         schema: Optional[str] = None,
     ) -> Table:
@@ -544,6 +519,8 @@ class DerivaML(Dataset):
         Args:
             asset_name: Name of the asset table.
             column_defs: Iterable of ColumnDefinition objects to provide additional metadata for asset.
+            fkey_defs: Iterable of ForeignKeyDefinition objects to provide additional metadata for asset.
+            referenced_tables: Iterable of Table objects to which asset should provide foreign-key references to.
             comment: Description of the asset table. (Default value = '')
             schema: Schema in which to create the asset table.  Defaults to domain_schema.
             asset_name: str:
@@ -553,17 +530,82 @@ class DerivaML(Dataset):
             Table object for the asset table.
         """
         column_defs = column_defs or []
+        fkey_defs = fkey_defs or []
+        referenced_tables = referenced_tables or []
         schema = schema or self.domain_schema
+
+        self.add_term(
+            MLVocab.asset_type, asset_name, description=f"A {asset_name} asset"
+        )
         asset_table = self.model.schemas[schema].create_table(
             Table.define_asset(
                 schema,
                 asset_name,
                 column_defs=[c.model_dump() for c in column_defs],
+                fkey_defs=[fk.model_dump() for fk in fkey_defs],
                 comment=comment,
             )
         )
+
+        self.model.schemas[self.domain_schema].create_table(
+            Table.define_association(
+                [
+                    (asset_table.name, asset_table),
+                    ("Asset_Type", self.model.name_to_table("Asset_Type")),
+                ]
+            )
+        )
+        for t in referenced_tables:
+            asset_table.create_reference(self.model.name_to_table(t))
+        # Create a table to track execution that creates the asset
+        atable = self.model.schemas[self.domain_schema].create_table(
+            Table.define_association(
+                [
+                    (asset_name, asset_table),
+                    (
+                        "Execution",
+                        self.model.schemas[self.ml_schema].tables["Execution"],
+                    ),
+                ]
+            )
+        )
+        atable.create_reference(self.model.name_to_table("Asset_Role"))
         return asset_table
 
+    # @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+    def list_assets(self, asset_table: Table | str):
+        """Return the contents of an asset table"""
+
+        if not self.model.is_asset(asset_table):
+            raise DerivaMLException(f"Table {asset_table.name} is not an asset")
+        asset_table = self.model.name_to_table(asset_table)
+        pb = self._model.catalog.getPathBuilder()
+        asset_path = pb.schemas[asset_table.schema.name].tables[asset_table.name]
+
+        asset_type_table = self._model.find_association(asset_table, MLVocab.asset_type)
+        type_path = pb.schemas[asset_type_table.schema.name].tables[
+            asset_type_table.name
+        ]
+
+        # Get a list of all the asset_type values associated with this dataset_table.
+        assets = []
+        for asset in asset_path.entities().fetch():
+            asset_types = (
+                type_path.filter(type_path.columns[asset_table.name] == asset["RID"])
+                .attributes(type_path.Asset_Type)
+                .fetch()
+            )
+            assets.append(
+                asset
+                | {
+                    MLVocab.asset_type.value: [
+                        asset_type[MLVocab.asset_type.value]
+                        for asset_type in asset_types
+                    ]
+                }
+            )
+        return assets
+
     @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
     def create_feature(
         self,
@@ -717,24 +759,6 @@ class DerivaML(Dataset):
         """
         return self.model.find_features(table)
 
-    @validate_call
-    def add_features(self, features: Iterable[FeatureRecord]) -> int:
-        """Add a set of new feature values to the catalog.
-
-        Args:
-          features: Iterable[FeatureRecord]:
-
-        Returns:
-            Number of attributes added
-        """
-        features = list(features)
-        feature_table = features[0].feature.feature_table
-        feature_path = self.pathBuilder.schemas[feature_table.schema.name].tables[
-            feature_table.name
-        ]
-        entries = feature_path.insert(f.model_dump() for f in features)
-        return len(entries)
-
     # noinspection PyProtectedMember
     @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
     def list_feature_values(
@@ -838,7 +862,8 @@ class DerivaML(Dataset):
             raise DerivaMLException(f"The table {table} is not a controlled vocabulary")
         schema_name, table_name = vocab_table.schema.name, vocab_table.name
         schema_path = self.catalog.getPathBuilder().schemas[schema_name]
-        for term in schema_path.tables[table_name].entities():
+
+        for term in schema_path.tables[table_name].entities().fetch():
             if term_name == term["Name"] or (
                 term["Synonyms"] and term_name in term["Synonyms"]
             ):
@@ -891,65 +916,6 @@ class DerivaML(Dataset):
             snapshot_catalog=DerivaML(self.host_name, self._version_snapshot(dataset)),
         )
 
-    @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
-    def download_asset(self, asset_rid: RID, dest_dir: Path) -> Path:
-        """Download an asset from a URL and place it in a local directory.
-
-        Args:
-            asset_rid: URL of the asset.
-            dest_dir: Destination directory for the asset.
-
-        Returns:
-            A  Path object to the downloaded asset.
-        """
-        table = self.resolve_rid(asset_rid).table
-        if not self.model.is_asset(table):
-            raise DerivaMLException(f"RID {asset_rid}  is not for an asset table.")
-
-        tpath = self.pathBuilder.schemas[table.schema.name].tables[table.name]
-        asset_metadata = list(tpath.filter(tpath.RID == asset_rid).entities())[0]
-        asset_url = asset_metadata["URL"]
-        asset_filename = dest_dir / asset_metadata["Filename"]
-
-        hs = HatracStore("https", self.host_name, self.credential)
-        hs.get_obj(path=asset_url, destfilename=asset_filename.as_posix())
-        return Path(asset_filename)
-
-    @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
-    def upload_assets(
-        self,
-        assets_dir: str | Path | UploadAssetDirectory,
-    ) -> dict[Any, FileUploadState] | None:
-        """Upload assets from a directory.
-
-        This routine assumes that the current upload specification includes a configuration for the specified directory.
-        Every asset in the specified directory is uploaded
-
-        Args:
-            assets_dir: Directory containing the assets to upload.
-
-        Returns:
-            Results of the upload operation.
-
-        Raises:
-            DerivaMLException: If there is an issue uploading the assets.
-        """
-
-        def path_to_asset(path: str) -> str:
-            """Pull the asset name out of a path to that asset in the filesystem"""
-            components = path.split("/")
-            return components[
-                components.index("asset") + 2
-            ]  # Look for asset in the path to find the name
-
-        if isinstance(assets_dir, UploadAssetDirectory):
-            assets_dir = assets_dir.path
-
-        if not self.model.is_asset(Path(assets_dir).name):
-            raise DerivaMLException("Directory does not have name of an asset table.")
-        results = upload_directory(self.model, assets_dir)
-        return {path_to_asset(p): r for p, r in results.items()}
-
     def _update_status(
         self, new_status: Status, status_detail: str, execution_rid: RID
     ):
@@ -1205,7 +1171,7 @@ class DerivaML(Dataset):
 
         """
 
-        # Get repo URL from local github repo.
+        # Get repo URL from local gitHub repo.
         try:
             result = subprocess.run(
                 ["git", "remote", "get-url", "origin"],
@@ -1261,7 +1227,7 @@ class DerivaML(Dataset):
 
         Args:
             configuration: ExecutionConfiguration:
-            dryrun: Do not create an execution record or upload results.
+            dry_run: Do not create an execution record or upload results.
 
         Returns:
             An execution object.
@@ -1283,13 +1249,11 @@ class DerivaML(Dataset):
                 raise DerivaMLException(f"Multiple execution RIDs were found {e_rids}.")
 
             execution_rid = e_rids[0]
-        cfile = (
-            execution_metadata_dir(
-                self.working_dir,
-                exec_rid=execution_rid,
-                metadata_type=ExecMetadataVocab.execution_config.value,
-            )
-            / "configuration.json"
+        cfile = asset_file_path(
+            prefix=self.working_dir,
+            exec_rid=execution_rid,
+            file_name="configuration.json",
+            asset_table=self.model.name_to_table("Execution_Metadata"),
         )
         configuration = ExecutionConfiguration.load_configuration(cfile)
         return Execution(configuration, self, reload=execution_rid)