Example #1
0
    def test_risk_mandatory_parameters(self):
        sections = [
            config.RISK_SECTION, config.HAZARD_SECTION, config.GENERAL_SECTION]

        dummy_exposure = self.touch()

        params = {}

        validator = config.default_validators(sections, params)
        self.assertFalse(validator.is_valid()[0])

        params = {config.EXPOSURE: dummy_exposure,
                  config.DEPTHTO1PT0KMPERSEC: "33.33",
                  config.VS30_TYPE: "measured"}

        validator = config.default_validators(sections, params)
        self.assertFalse(validator.is_valid()[0])

        params = {config.EXPOSURE: dummy_exposure,
                  config.REGION_GRID_SPACING: '0.5',
                  config.DEPTHTO1PT0KMPERSEC: "33.33",
                  config.VS30_TYPE: "measured"}

        validator = config.default_validators(sections, params)
        self.assertFalse(validator.is_valid()[0])

        params = {config.EXPOSURE: dummy_exposure,
                  config.INPUT_REGION: "1.0, 2.0, 3.0, 4.0, 5.0, 6.0",
                  config.REGION_GRID_SPACING: '0.5',
                  config.DEPTHTO1PT0KMPERSEC: "33.33",
                  config.VS30_TYPE: "measured"}

        validator = config.default_validators(sections, params)
        self.assertTrue(validator.is_valid()[0])
Example #2
0
    def test_in_default_validators(self):
        sections = ['HAZARD', 'RISK']
        params = dict(CALCULATION_MODE='Scenario')
        validators = config.default_validators(sections, params)

        self.assertTrue(
            any(isinstance(v, AssetCorrelationValidator) for v in validators))

        params = dict(CALCULATION_MODE='Event Based')
        validators = config.default_validators(sections, params)

        self.assertTrue(
            any(isinstance(v, AssetCorrelationValidator) for v in validators))
    def test_in_default_validators(self):
        sections = ['HAZARD', 'RISK']
        params = dict(CALCULATION_MODE='Scenario')
        validators = config.default_validators(sections, params)

        self.assertTrue(any(
            isinstance(v, AssetCorrelationValidator) for v in validators))

        params = dict(CALCULATION_MODE='Event Based')
        validators = config.default_validators(sections, params)

        self.assertTrue(any(
            isinstance(v, AssetCorrelationValidator) for v in validators))
Example #4
0
def import_job_profile(path_to_cfg,
                       job,
                       user_name='openquake',
                       force_inputs=False):
    """Given the path to a job config file, create a new
    :class:`openquake.db.models.OqJobProfile`, save it to the DB, and return
    it.

    :param str path_to_cfg:
        Path to a job config file.
    :param job:
        The :class:`openquake.db.models.OqJob` instance to use
    :param user_name:
        The user performing this action.
    :param bool force_inputs: If `True` the model input files will be parsed
        and the resulting content written to the database no matter what.

    :returns:
        A tuple of :class:`openquake.db.models.OqJobProfile` instance,
        params dict, and sections list.
        NOTE: The params and sections are temporary. These should be removed
        from the return value the future whenever possible to keep the API
        clean.
    """
    params, sections = _parse_config_file(path_to_cfg)
    params, sections = _prepare_config_parameters(params, sections)

    validator = jobconf.default_validators(sections, params)
    is_valid, errors = validator.is_valid()

    if not is_valid:
        raise jobconf.ValidationException(errors)

    job_profile = _prepare_job(params, sections, user_name, job, force_inputs)
    return job_profile, params, sections
Example #5
0
    def test_mandatory_hazard_params_without_java_names(self):
        """
        All mandatory hazard parameters must have the 'java_name' property
        set.
        """
        sections = [config.HAZARD_SECTION]

        params = {
            config.CALCULATION_MODE: "CLASSICAL",
            config.BASE_PATH: "/a/b/c",
            config.SITES: "37.9, -121.9",
            config.DEPTHTO1PT0KMPERSEC: "33.33",
            config.VS30_TYPE: "measured"
        }

        # Add a paramer *without* a 'java_name' property to the mandatory
        # hazard parameters list in order to provoke the error.
        HazardMandatoryParamsValidator.MANDATORY_PARAMS.append("BASE_PATH")

        # Now validate ..
        validator = config.default_validators(sections, params)
        result, msgs = validator.is_valid()

        # .. and check that the validation blew up due to the lack of the
        # 'java_name' property.
        self.assertFalse(result)
        self.assertEqual([
            "The following mandatory hazard parameter(s) lack a 'java_name' "
            "property: BASE_PATH"
        ], msgs)

        # Restore the list with the mandatory hazard parameters.
        HazardMandatoryParamsValidator.MANDATORY_PARAMS.pop()
Example #6
0
def _job_from_file(config_file, output_type, owner_username='******'):
    """
    Create a job from external configuration files.

    NOTE: This function is deprecated. Please use
    :function:`openquake.engine.import_job_profile`.

    :param config_file:
        The external configuration file path
    :param output_type:
        Where to store results:
        * 'db' database
        * 'xml' XML files *plus* database
    :param owner_username:
        oq_user.user_name which defines the owner of all DB artifacts created
        by this function.
    """

    # output_type can be set, in addition to 'db' and 'xml', also to
    # 'xml_without_db', which has the effect of serializing only to xml
    # without requiring a database at all.
    # This allows to run tests without requiring a database.
    # This is not documented in the public interface because it is
    # essentially a detail of our current tests and ci infrastructure.
    assert output_type in ('db', 'xml')

    params, sections = _parse_config_file(config_file)
    params, sections = _prepare_config_parameters(params, sections)
    job_profile = _prepare_job(params, sections)

    validator = jobconf.default_validators(sections, params)
    is_valid, errors = validator.is_valid()

    if not is_valid:
        raise jobconf.ValidationException(errors)

    owner = OqUser.objects.get(user_name=owner_username)
    # openquake-server creates the calculation record in advance and stores
    # the calculation id in the config file
    calculation_id = params.get('OPENQUAKE_JOB_ID')
    if not calculation_id:
        # create the database record for this calculation
        calculation = OqCalculation(owner=owner, path=None)
        calculation.oq_job_profile = job_profile
        calculation.save()
        calculation_id = calculation.id

    if output_type == 'db':
        serialize_results_to = ['db']
    else:
        serialize_results_to = ['db', 'xml']

    base_path = params['BASE_PATH']

    job = CalculationProxy(params, calculation_id, sections=sections,
                           base_path=base_path,
                           serialize_results_to=serialize_results_to)
    job.to_kvs()

    return job
Example #7
0
def import_job_profile(path_to_cfg, job, user_name='openquake',
                       force_inputs=False):
    """Given the path to a job config file, create a new
    :class:`openquake.db.models.OqJobProfile`, save it to the DB, and return
    it.

    :param str path_to_cfg:
        Path to a job config file.
    :param job:
        The :class:`openquake.db.models.OqJob` instance to use
    :param user_name:
        The user performing this action.
    :param bool force_inputs: If `True` the model input files will be parsed
        and the resulting content written to the database no matter what.

    :returns:
        A tuple of :class:`openquake.db.models.OqJobProfile` instance,
        params dict, and sections list.
        NOTE: The params and sections are temporary. These should be removed
        from the return value the future whenever possible to keep the API
        clean.
    """
    params, sections = _parse_config_file(path_to_cfg)
    params, sections = _prepare_config_parameters(params, sections)

    validator = jobconf.default_validators(sections, params)
    is_valid, errors = validator.is_valid()

    if not is_valid:
        raise jobconf.ValidationException(errors)

    job_profile = _prepare_job(params, sections, user_name, job, force_inputs)
    return job_profile, params, sections
Example #8
0
    def test_mandatory_hazard_params_without_java_names(self):
        """
        All mandatory hazard parameters must have the 'java_name' property
        set.
        """
        sections = [config.HAZARD_SECTION]

        params = {config.CALCULATION_MODE: "CLASSICAL",
                  config.BASE_PATH: "/a/b/c",
                  config.SITES: "37.9, -121.9",
                  config.DEPTHTO1PT0KMPERSEC: "33.33",
                  config.VS30_TYPE: "measured"}

        # Add a paramer *without* a 'java_name' property to the mandatory
        # hazard parameters list in order to provoke the error.
        HazardMandatoryParamsValidator.MANDATORY_PARAMS.append("BASE_PATH")

        # Now validate ..
        validator = config.default_validators(sections, params)
        result, msgs = validator.is_valid()

        # .. and check that the validation blew up due to the lack of the
        # 'java_name' property.
        self.assertFalse(result)
        self.assertEqual(
            ["The following mandatory hazard parameter(s) lack a 'java_name' "
             "property: BASE_PATH"], msgs)

        # Restore the list with the mandatory hazard parameters.
        HazardMandatoryParamsValidator.MANDATORY_PARAMS.pop()
Example #9
0
def import_job_profile(path_to_cfg):
    """Given the path to a job config file, create a new
    :class:`openquake.db.models.OqJobProfile` and save it to the DB, and return
    it.

    :param str path_to_cfg:
        Path to a job config file.

    :returns:
        A tuple of :class:`openquake.db.models.OqJobProfile` instance,
        params dict, and sections list.
        NOTE: The params and sections are temporary. These should be removed
        from the return value the future whenever possible to keep the API
        clean.
    """
    params, sections = _parse_config_file(path_to_cfg)
    params, sections = _prepare_config_parameters(params, sections)

    validator = jobconf.default_validators(sections, params)
    is_valid, errors = validator.is_valid()

    if not is_valid:
        raise jobconf.ValidationException(errors)

    job_profile = _prepare_job(params, sections)
    return job_profile, params, sections
Example #10
0
    def test_hazard_mandatory_parameters(self):
        sections = [config.HAZARD_SECTION]

        params = {config.CALCULATION_MODE: "CLASSICAL",
                  config.SITES: "37.9, -121.9",
                  config.DEPTHTO1PT0KMPERSEC: "33.33"}

        validator = config.default_validators(sections, params)
        self.assertFalse(validator.is_valid()[0])

        params = {config.CALCULATION_MODE: "CLASSICAL",
                  config.SITES: "37.9, -121.9",
                  config.DEPTHTO1PT0KMPERSEC: "33.33",
                  config.VS30_TYPE: "measured"}

        validator = config.default_validators(sections, params)
        self.assertTrue(validator.is_valid()[0])
Example #11
0
    def is_valid(self):
        """Return true if this job is valid and can be
        processed, false otherwise.

        :returns: the status of this job and the related error messages.
        :rtype: when valid, a (True, []) tuple is returned. When invalid, a
            (False, [ERROR_MESSAGE#1, ERROR_MESSAGE#2, ..., ERROR_MESSAGE#N])
            tuple is returned
        """

        return conf.default_validators(self.sections, self.params).is_valid()
Example #12
0
    def test_default_validators_classical_bcr_risk(self):
        # For Classical BCR Hazard+Risk calculations, ensure that a
        # `ClassicalRiskValidator` is included in the default validators.
        cfg_path = helpers.demo_file('benefit_cost_ratio/config.gem')

        job_profile, params, sections = engine.import_job_profile(cfg_path)

        validators = config.default_validators(sections, params)

        self.assertTrue(any(
            isinstance(v, ClassicalRiskValidator) for v in validators))
Example #13
0
    def test_default_validators_scenario_job(self):
        """Test to ensure that a Scenario job always includes the
        :class:`openquake.job.config.ScenarioComputationValidator`."""
        scenario_job_path = helpers.demo_file('scenario_risk/config.gem')
        scenario_job = helpers.job_from_file(scenario_job_path)

        validators = config.default_validators(scenario_job.sections,
                                               scenario_job.params)

        self.assertTrue(any(
            isinstance(v, ScenarioComputationValidator) for v in validators))
Example #14
0
    def from_file(config_file, output_type):
        """
        Create a job from external configuration files.

        :param config_file: the external configuration file path
        :param output_type: where to store results:
            * 'db' database
            * 'xml' XML files *plus* database
        :param params: optional dictionary of default parameters, overridden by
            the ones read from the config file
        :type params: :py:class:`dict`
        """

        # output_type can be set, in addition to 'db' and 'xml', also to
        # 'xml_without_db', which has the effect of serializing only to xml
        # without requiring a database at all.
        # This allows to run tests without requiring a database.
        # This is not documented in the public interface because it is
        # essentially a detail of our current tests and ci infrastructure.
        assert output_type in ('db', 'xml', 'xml_without_db')

        params, sections = parse_config_file(config_file)
        params, sections = prepare_config_parameters(params, sections)

        validator = conf.default_validators(sections, params)
        is_valid, errors = validator.is_valid()

        if not is_valid:
            raise conf.ValidationException(errors)

        if output_type == 'xml_without_db':
            # we are running a test
            job_id = 0
            serialize_results_to = ['xml']
        else:
            # openquake-server creates the job record in advance and stores the
            # job id in the config file
            job_id = params.get('OPENQUAKE_JOB_ID')
            if not job_id:
                # create the database record for this job
                job_id = prepare_job(params).id

            if output_type == 'db':
                serialize_results_to = ['db']
            else:
                serialize_results_to = ['db', 'xml']

        base_path = params['BASE_PATH']

        job = Job(params, job_id, sections=sections, base_path=base_path,
                  serialize_results_to=serialize_results_to)
        job.to_kvs()

        return job
Example #15
0
    def test_risk_mandatory_parameters(self):
        sections = [
            config.RISK_SECTION, config.HAZARD_SECTION, config.GENERAL_SECTION
        ]

        dummy_exposure = helpers.touch()

        params = {}

        validator = config.default_validators(sections, params)
        self.assertFalse(validator.is_valid()[0])

        params = {
            config.EXPOSURE: dummy_exposure,
            config.DEPTHTO1PT0KMPERSEC: "33.33",
            config.VS30_TYPE: "measured"
        }

        validator = config.default_validators(sections, params)
        self.assertFalse(validator.is_valid()[0])

        params = {
            config.EXPOSURE: dummy_exposure,
            config.REGION_GRID_SPACING: '0.5',
            config.DEPTHTO1PT0KMPERSEC: "33.33",
            config.VS30_TYPE: "measured"
        }

        validator = config.default_validators(sections, params)
        self.assertFalse(validator.is_valid()[0])

        params = {
            config.EXPOSURE: dummy_exposure,
            config.INPUT_REGION: "1.0, 2.0, 3.0, 4.0, 5.0, 6.0",
            config.REGION_GRID_SPACING: '0.5',
            config.DEPTHTO1PT0KMPERSEC: "33.33",
            config.VS30_TYPE: "measured"
        }

        validator = config.default_validators(sections, params)
        self.assertTrue(validator.is_valid()[0])
Example #16
0
    def test_default_validators_classical_bcr_risk(self):
        # For Classical BCR Hazard+Risk calculations, ensure that a
        # `ClassicalRiskValidator` is included in the default validators.
        cfg_path = helpers.demo_file('benefit_cost_ratio/config.gem')

        job_profile, params, sections = engine.import_job_profile(
            cfg_path, self.job)

        validators = config.default_validators(sections, params)

        self.assertTrue(
            any(isinstance(v, ClassicalRiskValidator) for v in validators))
Example #17
0
    def test_default_validators_disagg_job(self):
        """Test to ensure that a Disaggregation job always includes the
        :class:`openquake.job.config.DisaggregationValidator`.
        """
        da_job_path = helpers.demo_file('disaggregation/config.gem')
        da_job = helpers.job_from_file(da_job_path)

        validators = config.default_validators(da_job.sections, da_job.params)

        # test that the default validators include a DisaggregationValidator
        self.assertTrue(
            any(isinstance(v, DisaggregationValidator) for v in validators))
Example #18
0
    def test_hazard_mandatory_parameters(self):
        sections = [config.HAZARD_SECTION]

        params = {
            config.CALCULATION_MODE: "CLASSICAL",
            config.SITES: "37.9, -121.9",
            config.DEPTHTO1PT0KMPERSEC: "33.33"
        }

        validator = config.default_validators(sections, params)
        self.assertFalse(validator.is_valid()[0])

        params = {
            config.CALCULATION_MODE: "CLASSICAL",
            config.SITES: "37.9, -121.9",
            config.DEPTHTO1PT0KMPERSEC: "33.33",
            config.VS30_TYPE: "measured"
        }

        validator = config.default_validators(sections, params)
        self.assertTrue(validator.is_valid()[0])
Example #19
0
    def test_default_validators_event_based_bcr_risk(self):
        # For Event-Based BCR Risk calculations, ensure that a
        # `EventBasedRiskValidator` is included in the default validators.
        cfg_path = helpers.demo_file(
            'event_based_bcr_risk/config.gem')

        job_profile, params, sections = engine.import_job_profile(cfg_path)

        validators = config.default_validators(sections, params)

        self.assertTrue(any(
            isinstance(v, EventBasedRiskValidator) for v in validators))
Example #20
0
    def test_default_validators_event_based_bcr_risk(self):
        # For Event-Based BCR Risk calculations, ensure that a
        # `EventBasedRiskValidator` is included in the default validators.
        cfg_path = helpers.demo_file('benefit_cost_ratio/config_ebased.gem')

        job_profile, params, sections = engine.import_job_profile(
            cfg_path, self.job)

        validators = config.default_validators(sections, params)

        self.assertTrue(
            any(isinstance(v, EventBasedRiskValidator) for v in validators))
Example #21
0
    def test_default_validators_disagg_job(self):
        """Test to ensure that a Disaggregation job always includes the
        :class:`openquake.job.config.DisaggregationValidator`.
        """
        da_job_path = helpers.demo_file('disaggregation/config.gem')
        da_job = helpers.job_from_file(da_job_path)

        validators = config.default_validators(da_job.sections, da_job.params)

        # test that the default validators include a DisaggregationValidator
        self.assertTrue(any(
            isinstance(v, DisaggregationValidator) for v in validators))
Example #22
0
    def test_default_validators_scenario_job(self):
        """Test to ensure that a Scenario job always includes the
        :class:`openquake.job.config.ScenarioComputationValidator`."""
        scenario_job_path = helpers.demo_file('scenario_risk/config.gem')
        scenario_job = helpers.job_from_file(scenario_job_path)

        validators = config.default_validators(scenario_job.sections,
                                               scenario_job.params)

        self.assertTrue(
            any(
                isinstance(v, ScenarioComputationValidator)
                for v in validators))
Example #23
0
    def test_default_validators_classical_job(self):
        """Test to ensure that a classical always includes the
        :class:`openquake.job.config.ClassicalValidator`.
        """
        classical_risk_job_path = helpers.demo_file(
            'classical_psha_based_risk/config.gem')
        classical_risk_job = helpers.job_from_file(classical_risk_job_path)

        validators = config.default_validators(classical_risk_job.sections,
                                               classical_risk_job.params)

        self.assertTrue(
            any(isinstance(v, ClassicalValidator) for v in validators))
Example #24
0
    def test_default_validators_classical_job(self):
        """Test to ensure that a classical always includes the
        :class:`openquake.job.config.ClassicalValidator`.
        """
        classical_risk_job_path = helpers.demo_file(
            'classical_psha_based_risk/config.gem')
        classical_risk_job = helpers.job_from_file(classical_risk_job_path)

        validators = config.default_validators(classical_risk_job.sections,
                                               classical_risk_job.params)

        self.assertTrue(
            any(isinstance(v, ClassicalValidator) for v in validators))
Example #25
0
    def test_hazard_tasks(self):
        """
        The `HAZARD_TASKS` parameter is not ignored for classical PSHA
        calculations.
        """
        sections = [config.HAZARD_SECTION]

        params = {config.CALCULATION_MODE: "CLASSICAL",
                  config.SITES: "37.9, -121.9",
                  config.DEPTHTO1PT0KMPERSEC: "33.33",
                  config.VS30_TYPE: "measured",
                  config.HAZARD_TASKS: "96"}

        validator = config.default_validators(sections, params)
        self.assertTrue(validator.is_valid()[0])
Example #26
0
    def test_default_validators_scenario_damage_job(self):
        # Ensures that a Scenario Damage job always includes the
        # :class:`openquake.job.config.ScenarioComputationValidator` and
        # the :class:`openquake.job.config.ScenarioDamageComputationValidator`.

        scenario_job_path = helpers.demo_file(
            "scenario_damage_risk/config.gem")

        scenario_job = helpers.job_from_file(scenario_job_path)

        validators = config.default_validators(
            scenario_job.sections, scenario_job.params)

        self.assertTrue(any(isinstance(
                v, ScenarioComputationValidator) for v in validators))

        self.assertTrue(any(isinstance(
                v, ScenarioDamageValidator) for v in validators))
Example #27
0
    def test_default_validators_scenario_damage_job(self):
        # Ensures that a Scenario Damage job always includes the
        # :class:`openquake.job.config.ScenarioComputationValidator` and
        # the :class:`openquake.job.config.ScenarioDamageComputationValidator`.

        scenario_job_path = helpers.demo_file(
            "scenario_damage_risk/config.gem")

        scenario_job = helpers.job_from_file(scenario_job_path)

        validators = config.default_validators(scenario_job.sections,
                                               scenario_job.params)

        self.assertTrue(
            any(
                isinstance(v, ScenarioComputationValidator)
                for v in validators))

        self.assertTrue(
            any(isinstance(v, ScenarioDamageValidator) for v in validators))
Example #28
0
def _job_from_file(config_file,
                   output_type,
                   owner_username='******',
                   force_inputs=False):
    """
    Create a job from external configuration files.

    NOTE: This function is deprecated. Please use
    :function:`openquake.engine.import_job_profile`.

    :param config_file:
        The external configuration file path
    :param output_type:
        Where to store results:
        * 'db' database
        * 'xml' XML files *plus* database
    :param owner_username:
        oq_user.user_name which defines the owner of all DB artifacts created
        by this function.
    :param bool force_inputs: If `True` the model input files will be parsed
        and the resulting content written to the database no matter what.
    """

    # output_type can be set, in addition to 'db' and 'xml', also to
    # 'xml_without_db', which has the effect of serializing only to xml
    # without requiring a database at all.
    # This allows to run tests without requiring a database.
    # This is not documented in the public interface because it is
    # essentially a detail of our current tests and ci infrastructure.
    assert output_type in ('db', 'xml')

    params, sections = _parse_config_file(config_file)
    params, sections = _prepare_config_parameters(params, sections)

    validator = jobconf.default_validators(sections, params)
    is_valid, errors = validator.is_valid()

    if not is_valid:
        raise jobconf.ValidationException(errors)

    owner = OqUser.objects.get(user_name=owner_username)
    # openquake-server creates the job record in advance and stores
    # the calculation id in the config file
    job_id = params.get('OPENQUAKE_JOB_ID')
    if not job_id:
        # create the database record for this job
        job = OqJob(owner=owner, path=None)
        job.save()
        job_id = job.id
    else:
        job = OqJob.objects.get(job_id)

    job_profile = _prepare_job(params, sections, owner_username, job,
                               force_inputs)

    if output_type == 'db':
        serialize_results_to = ['db']
    else:
        serialize_results_to = ['db', 'xml']

    base_path = params['BASE_PATH']

    job_ctxt = JobContext(params,
                          job_id,
                          sections=sections,
                          base_path=base_path,
                          serialize_results_to=serialize_results_to,
                          oq_job=job,
                          oq_job_profile=job_profile)
    job_ctxt.to_kvs()

    return job_ctxt
Example #29
0
def _job_from_file(config_file, output_type, owner_username="******", force_inputs=False):
    """
    Create a job from external configuration files.

    NOTE: This function is deprecated. Please use
    :function:`openquake.engine.import_job_profile`.

    :param config_file:
        The external configuration file path
    :param output_type:
        Where to store results:
        * 'db' database
        * 'xml' XML files *plus* database
    :param owner_username:
        oq_user.user_name which defines the owner of all DB artifacts created
        by this function.
    :param bool force_inputs: If `True` the model input files will be parsed
        and the resulting content written to the database no matter what.
    """

    # output_type can be set, in addition to 'db' and 'xml', also to
    # 'xml_without_db', which has the effect of serializing only to xml
    # without requiring a database at all.
    # This allows to run tests without requiring a database.
    # This is not documented in the public interface because it is
    # essentially a detail of our current tests and ci infrastructure.
    assert output_type in ("db", "xml")

    params, sections = _parse_config_file(config_file)
    params, sections = _prepare_config_parameters(params, sections)

    validator = jobconf.default_validators(sections, params)
    is_valid, errors = validator.is_valid()

    if not is_valid:
        raise jobconf.ValidationException(errors)

    owner = OqUser.objects.get(user_name=owner_username)
    # openquake-server creates the job record in advance and stores
    # the calculation id in the config file
    job_id = params.get("OPENQUAKE_JOB_ID")
    if not job_id:
        # create the database record for this job
        job = OqJob(owner=owner, path=None)
        job.save()
        job_id = job.id
    else:
        job = OqJob.objects.get(job_id)

    job_profile = _prepare_job(params, sections, owner_username, job, force_inputs)

    if output_type == "db":
        serialize_results_to = ["db"]
    else:
        serialize_results_to = ["db", "xml"]

    base_path = params["BASE_PATH"]

    job_ctxt = JobContext(
        params,
        job_id,
        sections=sections,
        base_path=base_path,
        serialize_results_to=serialize_results_to,
        oq_job=job,
        oq_job_profile=job_profile,
    )
    job_ctxt.to_kvs()

    return job_ctxt