tracdap-runtime 0.6.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

tracdap/rt/_exec/dev_mode.py

@@ -12,8 +12,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from __future__ import annotations
-
 import re
 import typing as tp
 import copy
@@ -31,12 +29,20 @@ import tracdap.rt._impl.util as _util  # noqa
 
 
 DEV_MODE_JOB_CONFIG = [
-    re.compile(r"job\.run(Model|Flow)\.parameters\.\w+"),
-    re.compile(r"job\.run(Model|Flow)\.inputs\.\w+"),
-    re.compile(r"job\.run(Model|Flow)\.outputs\.\w+"),
-    re.compile(r"job\.runModel\.model"),
-    re.compile(r"job\.runFlow\.flow"),
-    re.compile(r"job\.runFlow\.models\.\w+")]
+    re.compile(r"job\.\w+\.parameters\.\w+"),
+    re.compile(r"job\.\w+\.inputs\.\w+"),
+    re.compile(r"job\.\w+\.outputs\.\w+"),
+    re.compile(r"job\.\w+\.models\.\w+"),
+    re.compile(r"job\.\w+\.model"),
+    re.compile(r"job\.\w+\.flow"),
+
+    re.compile(r".*\.jobs\.\d+\.\w+\.parameters\.\w+"),
+    re.compile(r".*\.jobs\.\d+\.\w+\.inputs\.\w+"),
+    re.compile(r".*\.jobs\.\d+\.\w+\.outputs\.\w+"),
+    re.compile(r".*\.jobs\.\d+\.\w+\.models\.\w+"),
+    re.compile(r".*\.jobs\.\d+\.\w+\.model"),
+    re.compile(r".*\.jobs\.\d+\.\w+\.flow")
+]
 
 DEV_MODE_SYS_CONFIG = []
 
@@ -56,43 +62,10 @@ class DevModeTranslator:
             sys_config.storage = _cfg.StorageConfig()
 
         sys_config = cls._add_integrated_repo(sys_config)
-        sys_config = cls._resolve_relative_storage_root(sys_config, config_mgr)
+        sys_config = cls._process_storage(sys_config, config_mgr)
 
         return sys_config
 
-    @classmethod
-    def translate_job_config(
-            cls,
-            sys_config: _cfg.RuntimeConfig,
-            job_config: _cfg.JobConfig,
-            scratch_dir: pathlib.Path,
-            config_mgr: _cfg_p.ConfigManager,
-            model_class: tp.Optional[_api.TracModel.__class__]) \
-            -> _cfg.JobConfig:
-
-        cls._log.info(f"Applying dev mode config translation to job config")
-
-        if not job_config.jobId:
-            job_config = cls._process_job_id(job_config)
-
-        if job_config.job.jobType is None or job_config.job.jobType == _meta.JobType.JOB_TYPE_NOT_SET:
-            job_config = cls._process_job_type(job_config)
-
-        # Load and populate any models provided as a Python class or class name
-        if job_config.job.jobType in [_meta.JobType.RUN_MODEL, _meta.JobType.RUN_FLOW]:
-            job_config = cls._process_models(sys_config, job_config, scratch_dir, model_class)
-
-        # Fow flows, load external flow definitions then perform auto-wiring and type inference
-        if job_config.job.jobType == _meta.JobType.RUN_FLOW:
-            job_config = cls._process_flow_definition(job_config, config_mgr)
-
-        # For run (model|flow) jobs, apply processing to the parameters, inputs and outputs
-        if job_config.job.jobType in [_meta.JobType.RUN_MODEL, _meta.JobType.RUN_FLOW]:
-            job_config = cls._process_parameters(job_config)
-            job_config = cls._process_inputs_and_outputs(sys_config, job_config)
-
-        return job_config
-
     @classmethod
     def _add_integrated_repo(cls, sys_config: _cfg.RuntimeConfig) -> _cfg.RuntimeConfig:
 
@@ -107,51 +80,140 @@ class DevModeTranslator:
         return sys_config
 
     @classmethod
-    def _resolve_relative_storage_root(
+    def _process_storage(
             cls, sys_config: _cfg.RuntimeConfig,
             config_mgr: _cfg_p.ConfigManager):
 
         storage_config = copy.deepcopy(sys_config.storage)
 
         for bucket_key, bucket_config in storage_config.buckets.items():
+            storage_config.buckets[bucket_key] = cls._resolve_storage_location(
+                bucket_key, bucket_config, config_mgr)
 
-            if bucket_config.protocol != "LOCAL":
-                continue
+        for bucket_key, bucket_config in storage_config.external.items():
+            storage_config.external[bucket_key] = cls._resolve_storage_location(
+                bucket_key, bucket_config, config_mgr)
 
-            if "rootPath" not in bucket_config.properties:
-                continue
+        sys_config = copy.copy(sys_config)
+        sys_config.storage = storage_config
 
-            root_path = pathlib.Path(bucket_config.properties["rootPath"])
+        return sys_config
+
+    @classmethod
+    def _resolve_storage_location(cls, bucket_key, bucket_config, config_mgr: _cfg_p.ConfigManager):
 
-            if root_path.is_absolute():
-                continue
+        if bucket_config.protocol != "LOCAL":
+            return bucket_config
 
-            cls._log.info(f"Resolving relative path for [{bucket_key}] local storage...")
+        if "rootPath" not in bucket_config.properties:
+            return bucket_config
 
-            sys_config_path = config_mgr.config_dir_path()
-            if sys_config_path is not None:
-                absolute_path = sys_config_path.joinpath(root_path).resolve()
-                if absolute_path.exists():
-                    cls._log.info(f"Resolved [{root_path}] -> [{absolute_path}]")
-                    bucket_config.properties["rootPath"] = str(absolute_path)
-                    continue
+        root_path = pathlib.Path(bucket_config.properties["rootPath"])
 
-            cwd = pathlib.Path.cwd()
-            absolute_path = cwd.joinpath(root_path).resolve()
+        if root_path.is_absolute():
+            return bucket_config
 
+        cls._log.info(f"Resolving relative path for [{bucket_key}] local storage...")
+
+        sys_config_path = config_mgr.config_dir_path()
+        if sys_config_path is not None:
+            absolute_path = sys_config_path.joinpath(root_path).resolve()
             if absolute_path.exists():
                 cls._log.info(f"Resolved [{root_path}] -> [{absolute_path}]")
                 bucket_config.properties["rootPath"] = str(absolute_path)
-                continue
+                return bucket_config
 
-            msg = f"Failed to resolve relative storage path [{root_path}]"
-            cls._log.error(msg)
-            raise _ex.EConfigParse(msg)
+        cwd = pathlib.Path.cwd()
+        absolute_path = cwd.joinpath(root_path).resolve()
 
-        sys_config = copy.copy(sys_config)
-        sys_config.storage = storage_config
+        if absolute_path.exists():
+            cls._log.info(f"Resolved [{root_path}] -> [{absolute_path}]")
+            bucket_config.properties["rootPath"] = str(absolute_path)
+            return bucket_config
 
-        return sys_config
+        msg = f"Failed to resolve relative storage path [{root_path}]"
+        cls._log.error(msg)
+        raise _ex.EConfigParse(msg)
+
+
+    def __init__(self, sys_config: _cfg.RuntimeConfig, config_mgr: _cfg_p.ConfigManager, scratch_dir: pathlib.Path):
+        self._sys_config = sys_config
+        self._config_mgr = config_mgr
+        self._scratch_dir = scratch_dir
+        self._model_loader: tp.Optional[_models.ModelLoader] = None
+
+    def translate_job_config(
+            self, job_config: _cfg.JobConfig,
+            model_class: tp.Optional[_api.TracModel.__class__] = None) \
+            -> _cfg.JobConfig:
+
+        try:
+            self._log.info(f"Applying dev mode config translation to job config")
+
+            self._model_loader = _models.ModelLoader(self._sys_config, self._scratch_dir)
+            self._model_loader.create_scope("DEV_MODE_TRANSLATION")
+
+            job_config = copy.deepcopy(job_config)
+            job_def = job_config.job
+
+            # Protobuf semantics for a blank jobId should be an object, but objectId will be an empty string
+            if not job_config.jobId or not job_config.jobId.objectId:
+                job_config = self._process_job_id(job_config)
+
+            job_config, job_def = self.translate_job_def(job_config, job_def, model_class)
+            job_config.job = job_def
+
+            return job_config
+
+        finally:
+            self._model_loader.destroy_scope("DEV_MODE_TRANSLATION")
+            self._model_loader = None
+
+    def translate_job_def(
+            self, job_config: _cfg.JobConfig, job_def: _meta.JobDefinition,
+            model_class: tp.Optional[_api.TracModel.__class__] = None) \
+            -> tp.Tuple[_cfg.JobConfig, _meta.JobDefinition]:
+
+        if job_def.jobType is None or job_def.jobType == _meta.JobType.JOB_TYPE_NOT_SET:
+            job_def = self._process_job_type(job_def)
+
+        # Load and populate any models provided as a Python class or class name
+        job_config, job_def = self._process_models(job_config, job_def, model_class)
+
+        # Fow flows, load external flow definitions then perform auto-wiring and type inference
+        if job_def.jobType == _meta.JobType.RUN_FLOW:
+            job_config, job_def = self._process_flow_definition(job_config, job_def)
+
+        if job_def.jobType == _meta.JobType.JOB_GROUP:
+            job_config, job_def = self.translate_job_group(job_config, job_def)
+
+        # Apply processing to the parameters, inputs and outputs
+        job_config, job_def = self._process_parameters(job_config, job_def)
+        job_config, job_def = self._process_inputs_and_outputs(job_config, job_def)
+
+        return job_config, job_def
+
+    def translate_job_group(
+            self, job_config: _cfg.JobConfig, job_def: _meta.JobDefinition) \
+            -> tp.Tuple[_cfg.JobConfig, _meta.JobDefinition]:
+
+        job_group = job_def.jobGroup
+
+        if job_group.jobGroupType is None or job_group.jobGroupType == _meta.JobGroupType.JOB_GROUP_TYPE_NOT_SET:
+            job_group = self._process_job_group_type(job_group)
+
+        group_details = self._get_job_group_detail(job_group)
+
+        if hasattr(group_details, "jobs"):
+            child_jobs = []
+            for child_def in group_details.jobs:
+                job_config, child_def = self.translate_job_def(job_config, child_def)
+                child_jobs.append(child_def)
+            group_details.jobs = child_jobs
+
+        job_def.jobGroup = job_group
+
+        return job_config, job_def
 
     @classmethod
     def _add_job_resource(
@@ -177,101 +239,153 @@ class DevModeTranslator:
         return translated_config
 
     @classmethod
-    def _process_job_type(cls, job_config: _cfg.JobConfig):
+    def _process_job_type(cls, job_def: _meta.JobDefinition):
 
-        if job_config.job.runModel is not None:
+        if job_def.runModel is not None:
             job_type = _meta.JobType.RUN_MODEL
 
-        elif job_config.job.runFlow is not None:
+        elif job_def.runFlow is not None:
             job_type = _meta.JobType.RUN_FLOW
 
-        elif job_config.job.importModel is not None:
+        elif job_def.importModel is not None:
             job_type = _meta.JobType.IMPORT_MODEL
 
+        elif job_def.importData is not None:
+            job_type = _meta.JobType.IMPORT_DATA
+
+        elif job_def.exportData is not None:
+            job_type = _meta.JobType.EXPORT_DATA
+
+        elif job_def.jobGroup is not None:
+            job_type = _meta.JobType.JOB_GROUP
+
         else:
             cls._log.error("Could not infer job type")
             raise _ex.EConfigParse("Could not infer job type")
 
         cls._log.info(f"Inferred job type = [{job_type.name}]")
 
-        job_def = copy.copy(job_config.job)
+        job_def = copy.copy(job_def)
         job_def.jobType = job_type
 
-        job_config = copy.copy(job_config)
-        job_config.job = job_def
-
-        return job_config
+        return job_def
 
     @classmethod
-    def _process_models(
-            cls,
-            sys_config: _cfg.RuntimeConfig,
-            job_config: _cfg.JobConfig,
-            scratch_dir: pathlib.Path,
-            model_class: tp.Optional[_api.TracModel.__class__]) \
-            -> _cfg.JobConfig:
+    def _process_job_group_type(cls, job_group: _meta.JobGroup) -> _meta.JobGroup:
 
-        model_loader = _models.ModelLoader(sys_config, scratch_dir)
-        model_loader.create_scope("DEV_MODE_TRANSLATION")
+        if job_group.sequential is not None:
+            job_group_type = _meta.JobGroupType.SEQUENTIAL_JOB_GROUP
 
-        original_config = job_config
+        elif job_group.parallel is not None:
+            job_group_type = _meta.JobGroupType.PARALLEL_JOB_GROUP
 
-        job_config = copy.copy(job_config)
-        job_config.job = copy.copy(job_config.job)
-        job_config.resources = copy.copy(job_config.resources)
+        else:
+            cls._log.error("Could not infer job group type")
+            raise _ex.EConfigParse("Could not infer job group type")
 
-        if job_config.job.jobType == _meta.JobType.RUN_MODEL:
+        cls._log.info(f"Inferred job group type = [{job_group_type.name}]")
 
-            job_config.job.runModel = copy.copy(job_config.job.runModel)
+        job_group = copy.copy(job_group)
+        job_group.jobGroupType = job_group_type
 
-            # If a model class is supplied in code, use that to generate the model def
-            if model_class is not None:
-                model_id, model_obj = cls._generate_model_for_class(model_loader, model_class)
-                job_config = cls._add_job_resource(job_config, model_id, model_obj)
-                job_config.job.runModel.model = _util.selector_for(model_id)
+        return job_group
 
-            # Otherwise if model specified as a string instead of a selector, apply the translation
-            elif isinstance(original_config.job.runModel.model, str):
-                model_detail = original_config.job.runModel.model
-                model_id, model_obj = cls._generate_model_for_entry_point(model_loader, model_detail)  # noqa
-                job_config = cls._add_job_resource(job_config, model_id, model_obj)
-                job_config.job.runModel.model = _util.selector_for(model_id)
+    @classmethod
+    def _get_job_detail(cls, job_def: _meta.JobDefinition):
 
-        if job_config.job.jobType == _meta.JobType.RUN_FLOW:
+        if job_def.jobType == _meta.JobType.RUN_MODEL:
+            return job_def.runModel
 
-            job_config.job.runFlow = copy.copy(job_config.job.runFlow)
-            job_config.job.runFlow.models = copy.copy(job_config.job.runFlow.models)
+        if job_def.jobType == _meta.JobType.RUN_FLOW:
+            return job_def.runFlow
 
-            for model_key, model_detail in original_config.job.runFlow.models.items():
+        if job_def.jobType == _meta.JobType.IMPORT_MODEL:
+            return job_def.importModel
 
-                # Only apply translation if the model is specified as a string instead of a selector
-                if isinstance(model_detail, str):
-                    model_id, model_obj = cls._generate_model_for_entry_point(model_loader, model_detail)
-                    job_config = cls._add_job_resource(job_config, model_id, model_obj)
-                    job_config.job.runFlow.models[model_key] = _util.selector_for(model_id)
+        if job_def.jobType == _meta.JobType.IMPORT_DATA:
+            return job_def.importData
 
-        model_loader.destroy_scope("DEV_MODE_TRANSLATION")
+        if job_def.jobType == _meta.JobType.EXPORT_DATA:
+            return job_def.exportData
 
-        return job_config
+        if job_def.jobType == _meta.JobType.JOB_GROUP:
+            return job_def.jobGroup
+
+        raise _ex.EConfigParse(f"Could not get job details for job type [{job_def.jobType}]")
 
     @classmethod
+    def _get_job_group_detail(cls, job_group: _meta.JobGroup):
+
+        if job_group.jobGroupType == _meta.JobGroupType.SEQUENTIAL_JOB_GROUP:
+            return job_group.sequential
+
+        if job_group.jobGroupType == _meta.JobGroupType.PARALLEL_JOB_GROUP:
+            return job_group.parallel
+
+        raise _ex.EConfigParse(f"Could not get job group details for group type [{job_group.jobGroupType}]")
+
+    def _process_models(
+            self, job_config: _cfg.JobConfig, job_def: _meta.JobDefinition,
+            model_class: tp.Optional[_api.TracModel.__class__]) \
+            -> tp.Tuple[_cfg.JobConfig, _meta.JobDefinition]:
+
+        # This processing works on the assumption that job details follow a convention for addressing models
+        # Jobs requiring a single model have a field called "model"
+        # Jobs requiring multiple models have a field called "models@, which is a dict
+
+        job_detail = self._get_job_detail(job_def)
+
+        # If a model class is supplied in code, use that to generate the model def
+        if model_class is not None:
+
+            # Passing a model class via launch_model() is only supported for job types with a single model
+            if not hasattr(job_detail, "model"):
+                raise _ex.EJobValidation(f"Job type [{job_def.jobType}] cannot be launched using launch_model()")
+
+            model_id, model_obj = self._generate_model_for_class(model_class)
+            job_detail.model = _util.selector_for(model_id)
+            job_config = self._add_job_resource(job_config, model_id, model_obj)
+
+        # Otherwise look for models specified as a single string, and take that as the entry point
+        else:
+
+            # Jobs with a single model
+            if hasattr(job_detail, "model") and isinstance(job_detail.model, str):
+                model_id, model_obj = self._generate_model_for_entry_point(job_detail.model)  # noqa
+                job_detail.model = _util.selector_for(model_id)
+                job_config = self._add_job_resource(job_config, model_id, model_obj)
+
+            elif hasattr(job_detail, "model") and isinstance(job_detail.model, _meta.TagSelector):
+                if job_detail.model.objectType == _meta.ObjectType.OBJECT_TYPE_NOT_SET:
+                    error = f"Missing required property [model] for job type [{job_def.jobType.name}]"
+                    self._log.error(error)
+                    raise _ex.EJobValidation(error)
+
+            # Jobs with multiple models
+            elif hasattr(job_detail, "models") and isinstance(job_detail.models, dict):
+                for model_key, model_detail in job_detail.models.items():
+                    if isinstance(model_detail, str):
+                        model_id, model_obj = self._generate_model_for_entry_point(model_detail)
+                        job_detail.models[model_key] = _util.selector_for(model_id)
+                        job_config = self._add_job_resource(job_config, model_id, model_obj)
+
+        return job_config, job_def
+
     def _generate_model_for_class(
-            cls, model_loader: _models.ModelLoader, model_class: _api.TracModel.__class__) \
+            self, model_class: _api.TracModel.__class__) \
             -> (_meta.TagHeader, _meta.ObjectDefinition):
 
         model_entry_point = f"{model_class.__module__}.{model_class.__name__}"
+        return self._generate_model_for_entry_point(model_entry_point)
 
-        return cls._generate_model_for_entry_point(model_loader, model_entry_point)
-
-    @classmethod
     def _generate_model_for_entry_point(
-            cls, model_loader: _models.ModelLoader, model_entry_point: str) \
+            self, model_entry_point: str) \
             -> (_meta.TagHeader, _meta.ObjectDefinition):
 
         model_id = _util.new_object_id(_meta.ObjectType.MODEL)
         model_key = _util.object_key(model_id)
 
-        cls._log.info(f"Generating model definition for [{model_entry_point}] with ID = [{model_key}]")
+        self._log.info(f"Generating model definition for [{model_entry_point}] with ID = [{model_key}]")
 
         skeleton_modeL_def = _meta.ModelDefinition(  # noqa
             language="python",
@@ -282,8 +396,8 @@ class DevModeTranslator:
             inputs={},
             outputs={})
 
-        model_class = model_loader.load_model_class("DEV_MODE_TRANSLATION", skeleton_modeL_def)
-        model_def = model_loader.scan_model(skeleton_modeL_def, model_class)
+        model_class = self._model_loader.load_model_class("DEV_MODE_TRANSLATION", skeleton_modeL_def)
+        model_def = self._model_loader.scan_model(skeleton_modeL_def, model_class)
 
         model_object = _meta.ObjectDefinition(
             objectType=_meta.ObjectType.MODEL,
@@ -291,56 +405,57 @@ class DevModeTranslator:
 
         return model_id, model_object
 
-    @classmethod
-    def _process_flow_definition(cls, job_config: _cfg.JobConfig, config_mgr: _cfg_p.ConfigManager) -> _cfg.JobConfig:
+    def _process_flow_definition(
+            self, job_config: _cfg.JobConfig, job_def: _meta.JobDefinition) \
+            -> tp.Tuple[_cfg.JobConfig, _meta.JobDefinition]:
 
-        flow_details = job_config.job.runFlow.flow
+        flow_details = job_def.runFlow.flow
 
         # Do not apply translation if flow is specified as an object ID / selector (assume full config is supplied)
         if isinstance(flow_details, _meta.TagHeader) or isinstance(flow_details, _meta.TagSelector):
-            return job_config
+            return job_config, job_def
 
         # Otherwise, flow is specified as the path to dev-mode flow definition
         if not isinstance(flow_details, str):
             err = f"Invalid config value for [job.runFlow.flow]: Expected path or tag selector, got [{flow_details}])"
-            cls._log.error(err)
+            self._log.error(err)
             raise _ex.EConfigParse(err)
 
         flow_id = _util.new_object_id(_meta.ObjectType.FLOW)
         flow_key = _util.object_key(flow_id)
 
-        cls._log.info(f"Generating flow definition from [{flow_details}] with ID = [{flow_key}]")
+        self._log.info(f"Generating flow definition from [{flow_details}] with ID = [{flow_key}]")
 
-        flow_def = config_mgr.load_config_object(flow_details, _meta.FlowDefinition)
+        flow_def = self._config_mgr.load_config_object(flow_details, _meta.FlowDefinition)
 
         # Validate models against the flow (this could move to _impl.validation and check prod jobs as well)
-        cls._check_models_for_flow(flow_def, job_config)
+        self._check_models_for_flow(flow_def, job_def, job_config)
 
         # Auto-wiring and inference only applied to externally loaded flows for now
-        flow_def = cls._autowire_flow(flow_def, job_config)
-        flow_def = cls._apply_type_inference(flow_def, job_config)
+        flow_def = self._autowire_flow(flow_def, job_def, job_config)
+        flow_def = self._apply_type_inference(flow_def, job_def, job_config)
 
         flow_obj = _meta.ObjectDefinition(
             objectType=_meta.ObjectType.FLOW,
             flow=flow_def)
 
+        job_def = copy.copy(job_def)
+        job_def.runFlow = copy.copy(job_def.runFlow)
+        job_def.runFlow.flow = _util.selector_for(flow_id)
+
         job_config = copy.copy(job_config)
-        job_config.job = copy.copy(job_config.job)
-        job_config.job.runFlow = copy.copy(job_config.job.runFlow)
         job_config.resources = copy.copy(job_config.resources)
+        job_config = self._add_job_resource(job_config, flow_id, flow_obj)
 
-        job_config = cls._add_job_resource(job_config, flow_id, flow_obj)
-        job_config.job.runFlow.flow = _util.selector_for(flow_id)
-
-        return job_config
+        return job_config, job_def
 
     @classmethod
-    def _check_models_for_flow(cls, flow: _meta.FlowDefinition, job_config: _cfg.JobConfig):
+    def _check_models_for_flow(cls, flow: _meta.FlowDefinition, job_def: _meta.JobDefinition, job_config: _cfg.JobConfig):
 
         model_nodes = dict(filter(lambda n: n[1].nodeType == _meta.FlowNodeType.MODEL_NODE, flow.nodes.items()))
 
-        missing_models = list(filter(lambda m: m not in job_config.job.runFlow.models, model_nodes.keys()))
-        extra_models = list(filter(lambda m: m not in model_nodes, job_config.job.runFlow.models.keys()))
+        missing_models = list(filter(lambda m: m not in job_def.runFlow.models, model_nodes.keys()))
+        extra_models = list(filter(lambda m: m not in model_nodes, job_def.runFlow.models.keys()))
 
         if any(missing_models):
             error = f"Missing models in job definition: {', '.join(missing_models)}"
@@ -354,7 +469,7 @@ class DevModeTranslator:
 
         for model_name, model_node in model_nodes.items():
 
-            model_selector = job_config.job.runFlow.models[model_name]
+            model_selector = job_def.runFlow.models[model_name]
             model_obj = _util.get_job_resource(model_selector, job_config)
 
             model_inputs = set(model_obj.model.inputs.keys())
@@ -366,9 +481,9 @@ class DevModeTranslator:
                 raise _ex.EJobValidation(error)
 
     @classmethod
-    def _autowire_flow(cls, flow: _meta.FlowDefinition, job_config: _cfg.JobConfig):
+    def _autowire_flow(cls, flow: _meta.FlowDefinition, job_def: _meta.JobDefinition, job_config: _cfg.JobConfig):
 
-        job = job_config.job.runFlow
+        job = job_def.runFlow
         nodes = copy.copy(flow.nodes)
         edges: tp.Dict[str, _meta.FlowEdge] = dict()
 
@@ -455,7 +570,10 @@ class DevModeTranslator:
         return autowired_flow
 
     @classmethod
-    def _apply_type_inference(cls, flow: _meta.FlowDefinition, job_config: _cfg.JobConfig) -> _meta.FlowDefinition:
+    def _apply_type_inference(
+            cls, flow: _meta.FlowDefinition,
+            job_def: _meta.JobDefinition, job_config: _cfg.JobConfig) \
+            -> _meta.FlowDefinition:
 
         updated_flow = copy.copy(flow)
         updated_flow.parameters = copy.copy(flow.parameters)
@@ -476,17 +594,17 @@ class DevModeTranslator:
 
             if node.nodeType == _meta.FlowNodeType.PARAMETER_NODE and node_name not in flow.parameters:
                 targets = edges_by_source.get(node_name) or []
-                model_parameter = cls._infer_parameter(node_name, targets, job_config)
+                model_parameter = cls._infer_parameter(node_name, targets, job_def, job_config)
                 updated_flow.parameters[node_name] = model_parameter
 
             if node.nodeType == _meta.FlowNodeType.INPUT_NODE and node_name not in flow.inputs:
                 targets = edges_by_source.get(node_name) or []
-                model_input = cls._infer_input_schema(node_name, targets, job_config)
+                model_input = cls._infer_input_schema(node_name, targets, job_def, job_config)
                 updated_flow.inputs[node_name] = model_input
 
             if node.nodeType == _meta.FlowNodeType.OUTPUT_NODE and node_name not in flow.outputs:
                 sources = edges_by_target.get(node_name) or []
-                model_output = cls._infer_output_schema(node_name, sources, job_config)
+                model_output = cls._infer_output_schema(node_name, sources, job_def, job_config)
                 updated_flow.outputs[node_name] = model_output
 
         return updated_flow
@@ -494,13 +612,14 @@ class DevModeTranslator:
     @classmethod
     def _infer_parameter(
             cls, param_name: str, targets: tp.List[_meta.FlowSocket],
-            job_config: _cfg.JobConfig) -> _meta.ModelParameter:
+            job_def: _meta.JobDefinition, job_config: _cfg.JobConfig) \
+            -> _meta.ModelParameter:
 
         model_params = []
 
         for target in targets:
 
-            model_selector = job_config.job.runFlow.models.get(target.node)
+            model_selector = job_def.runFlow.models.get(target.node)
             model_obj = _util.get_job_resource(model_selector, job_config)
             model_param = model_obj.model.parameters.get(target.socket)
             model_params.append(model_param)
@@ -530,13 +649,14 @@ class DevModeTranslator:
     @classmethod
     def _infer_input_schema(
             cls, input_name: str, targets: tp.List[_meta.FlowSocket],
-            job_config: _cfg.JobConfig) -> _meta.ModelInputSchema:
+            job_def: _meta.JobDefinition, job_config: _cfg.JobConfig) \
+            -> _meta.ModelInputSchema:
 
         model_inputs = []
 
         for target in targets:
 
-            model_selector = job_config.job.runFlow.models.get(target.node)
+            model_selector = job_def.runFlow.models.get(target.node)
             model_obj = _util.get_job_resource(model_selector, job_config)
             model_input = model_obj.model.inputs.get(target.socket)
             model_inputs.append(model_input)
@@ -564,13 +684,14 @@ class DevModeTranslator:
     @classmethod
     def _infer_output_schema(
             cls, output_name: str, sources: tp.List[_meta.FlowSocket],
-            job_config: _cfg.JobConfig) -> _meta.ModelOutputSchema:
+            job_def: _meta.JobDefinition, job_config: _cfg.JobConfig) \
+            -> _meta.ModelOutputSchema:
 
         model_outputs = []
 
         for source in sources:
 
-            model_selector = job_config.job.runFlow.models.get(source.node)
+            model_selector = job_def.runFlow.models.get(source.node)
             model_obj = _util.get_job_resource(model_selector, job_config)
             model_input = model_obj.model.inputs.get(source.socket)
             model_outputs.append(model_input)
@@ -594,37 +715,38 @@ class DevModeTranslator:
         return f"{socket.node}.{socket.socket}" if socket.socket else socket.node
 
     @classmethod
-    def _process_parameters(cls, job_config: _cfg.JobConfig) -> _cfg.JobConfig:
+    def _process_parameters(
+            cls, job_config: _cfg.JobConfig, job_def: _meta.JobDefinition) \
+            -> tp.Tuple[_cfg.JobConfig, _meta.JobDefinition]:
 
-        if job_config.job.jobType == _meta.JobType.RUN_MODEL:
-
-            job_details = job_config.job.runModel
-            model_key = _util.object_key(job_details.model)
-            model_or_flow = job_config.resources[model_key].model
+        # This relies on convention for naming properties across similar job types
 
-        elif job_config.job.jobType == _meta.JobType.RUN_FLOW:
+        job_detail = cls._get_job_detail(job_def)
 
-            job_details = job_config.job.runFlow
-            flow_key = _util.object_key(job_details.flow)
+        if hasattr(job_detail, "model"):
+            model_key = _util.object_key(job_detail.model)
+            model_or_flow = job_config.resources[model_key].model
+        elif hasattr(job_detail, "flow"):
+            flow_key = _util.object_key(job_detail.flow)
             model_or_flow = job_config.resources[flow_key].flow
-
         else:
-            raise _ex.EUnexpected()
+            model_or_flow = None
 
-        param_specs = model_or_flow.parameters
-        param_values = job_details.parameters
+        if model_or_flow is not None:
 
-        # Set encoded params on runModel or runFlow depending on the job type
-        job_details.parameters = cls._process_parameters_dict(param_specs, param_values)
+            param_specs = model_or_flow.parameters
+            raw_values = job_detail.parameters
 
-        return job_config
+            job_detail.parameters = cls._process_parameters_dict(param_specs, raw_values)
+
+        return job_config, job_def
 
     @classmethod
     def _process_parameters_dict(
             cls, param_specs: tp.Dict[str, _meta.ModelParameter],
-            param_values: tp.Dict[str, _meta.Value]) -> tp.Dict[str, _meta.Value]:
+            raw_values: tp.Dict[str, _meta.Value]) -> tp.Dict[str, _meta.Value]:
 
-        unknown_params = list(filter(lambda p: p not in param_specs, param_values))
+        unknown_params = list(filter(lambda p: p not in param_specs, raw_values))
 
         if any(unknown_params):
             msg = f"Unknown parameters cannot be translated: [{', '.join(unknown_params)}]"
@@ -633,7 +755,7 @@ class DevModeTranslator:
 
         encoded_values = dict()
 
-        for p_name, p_value in param_values.items():
+        for p_name, p_value in raw_values.items():
 
             if isinstance(p_value, _meta.Value):
                 encoded_values[p_name] = p_value
@@ -648,26 +770,27 @@ class DevModeTranslator:
 
         return encoded_values
 
-    @classmethod
-    def _process_inputs_and_outputs(cls, sys_config: _cfg.RuntimeConfig, job_config: _cfg.JobConfig) -> _cfg.JobConfig:
+    def _process_inputs_and_outputs(
+            self, job_config: _cfg.JobConfig, job_def: _meta.JobDefinition) \
+            -> tp.Tuple[_cfg.JobConfig, _meta.JobDefinition]:
+
+        job_detail = self._get_job_detail(job_def)
 
-        if job_config.job.jobType == _meta.JobType.RUN_MODEL:
-            job_details = job_config.job.runModel
-            model_obj = _util.get_job_resource(job_details.model, job_config)
+        if hasattr(job_detail, "model"):
+            model_obj = _util.get_job_resource(job_detail.model, job_config)
             required_inputs = model_obj.model.inputs
             required_outputs = model_obj.model.outputs
 
-        elif job_config.job.jobType == _meta.JobType.RUN_FLOW:
-            job_details = job_config.job.runFlow
-            flow_obj = _util.get_job_resource(job_details.flow, job_config)
+        elif hasattr(job_detail, "flow"):
+            flow_obj = _util.get_job_resource(job_detail.flow, job_config)
             required_inputs = flow_obj.flow.inputs
             required_outputs = flow_obj.flow.outputs
 
         else:
-            return job_config
+            return job_config, job_def
 
-        job_inputs = job_details.inputs
-        job_outputs = job_details.outputs
+        job_inputs = job_detail.inputs
+        job_outputs = job_detail.outputs
         job_resources = job_config.resources
 
         for input_key, input_value in job_inputs.items():
@@ -676,8 +799,8 @@ class DevModeTranslator:
                 model_input = required_inputs[input_key]
                 input_schema = model_input.schema if model_input and not model_input.dynamic else None
 
-                input_id = cls._process_input_or_output(
-                    sys_config, input_key, input_value, job_resources,
+                input_id = self._process_input_or_output(
+                    input_key, input_value, job_resources,
                     new_unique_file=False, schema=input_schema)
 
                 job_inputs[input_key] = _util.selector_for(input_id)
@@ -688,17 +811,16 @@ class DevModeTranslator:
                 model_output= required_outputs[output_key]
                 output_schema = model_output.schema if model_output and not model_output.dynamic else None
 
-                output_id = cls._process_input_or_output(
-                    sys_config, output_key, output_value, job_resources,
+                output_id = self._process_input_or_output(
+                   output_key, output_value, job_resources,
                     new_unique_file=True, schema=output_schema)
 
                 job_outputs[output_key] = _util.selector_for(output_id)
 
-        return job_config
+        return job_config, job_def
 
-    @classmethod
     def _process_input_or_output(
-            cls, sys_config, data_key, data_value,
+            self, data_key, data_value,
             resources: tp.Dict[str, _meta.ObjectDefinition],
             new_unique_file=False,
             schema: tp.Optional[_meta.SchemaDefinition] = None) \
@@ -709,8 +831,8 @@ class DevModeTranslator:
 
         if isinstance(data_value, str):
             storage_path = data_value
-            storage_key = sys_config.storage.defaultBucket
-            storage_format = cls.infer_format(storage_path, sys_config.storage)
+            storage_key = self._sys_config.storage.defaultBucket
+            storage_format = self.infer_format(storage_path, self._sys_config.storage)
             snap_version = 1
 
         elif isinstance(data_value, dict):
@@ -720,14 +842,14 @@ class DevModeTranslator:
             if not storage_path:
                 raise _ex.EConfigParse(f"Invalid configuration for input [{data_key}] (missing required value 'path'")
 
-            storage_key = data_value.get("storageKey") or sys_config.storage.defaultBucket
-            storage_format = data_value.get("format") or cls.infer_format(storage_path, sys_config.storage)
+            storage_key = data_value.get("storageKey") or self._sys_config.storage.defaultBucket
+            storage_format = data_value.get("format") or self.infer_format(storage_path, self._sys_config.storage)
             snap_version = 1
 
         else:
             raise _ex.EConfigParse(f"Invalid configuration for input '{data_key}'")
 
-        cls._log.info(f"Generating data definition for [{data_key}] with ID = [{_util.object_key(data_id)}]")
+        self._log.info(f"Generating data definition for [{data_key}] with ID = [{_util.object_key(data_id)}]")
 
         # For unique outputs, increment the snap number to find a new unique snap
         # These are not incarnations, bc likely in dev mode model code and inputs are changing
@@ -735,7 +857,7 @@ class DevModeTranslator:
 
         if new_unique_file:
 
-            x_storage_mgr = _storage.StorageManager(sys_config)
+            x_storage_mgr = _storage.StorageManager(self._sys_config)
             x_storage = x_storage_mgr.get_file_storage(storage_key)
             x_orig_path = pathlib.PurePath(storage_path)
             x_name = x_orig_path.name
@@ -752,9 +874,9 @@ class DevModeTranslator:
                 x_name = f"{x_orig_path.stem}-{snap_version}"
                 storage_path = str(x_orig_path.parent.joinpath(x_name))
 
-            cls._log.info(f"Output for [{data_key}] will be snap version {snap_version}")
+            self._log.info(f"Output for [{data_key}] will be snap version {snap_version}")
 
-        data_obj, storage_obj = cls._generate_input_definition(
+        data_obj, storage_obj = self._generate_input_definition(
             data_id, storage_id, storage_key, storage_path, storage_format,
             snap_index=snap_version, delta_index=1, incarnation_index=1,
             schema=schema)