def test_step_versions_with_resources(): run_config = {"resources": {"test_resource": {"config": {"input_str": "apple"}}}} speculative_execution_plan = create_execution_plan( versioned_modes_pipeline, run_config=run_config, ) versions = resolve_step_versions_for_test( speculative_execution_plan, run_config=run_config, mode="fakemode" ) solid_def_version = fake_solid_resources_versioned.version solid_config_version = resolve_config_version(None) environment_config = EnvironmentConfig.build( versioned_modes_pipeline, mode="fakemode", run_config=run_config ) resource_versions_by_key = resolve_resource_versions( environment_config, versioned_modes_pipeline.get_mode_definition("fakemode") ) solid_resources_version = join_and_hash( *[ resource_versions_by_key[resource_key] for resource_key in fake_solid_resources_versioned.required_resource_keys ] ) solid_version = join_and_hash(solid_def_version, solid_config_version, solid_resources_version) step_version = join_and_hash(solid_version) assert versions["fake_solid_resources_versioned.compute"] == step_version
def versioned_pipeline_expected_step1_version(): solid1_def_version = versioned_solid_no_input.version solid1_config_version = resolve_config_version(None) solid1_resources_version = join_and_hash() solid1_version = join_and_hash(solid1_def_version, solid1_config_version, solid1_resources_version) return join_and_hash(solid1_version)
def test_resource_versions(): run_config = { "resources": { "test_resource": { "config": {"input_str": "apple"}, }, "test_resource_no_version": {"config": {"input_str": "banana"}}, } } execution_plan = create_execution_plan(modes_pipeline, run_config=run_config, mode="fakemode") resource_versions_by_key = resolve_resource_versions( execution_plan.environment_config, execution_plan.pipeline.get_definition() ) assert resource_versions_by_key["test_resource"] == join_and_hash( resolve_config_version({"input_str": "apple"}), test_resource.version ) assert resource_versions_by_key["test_resource_no_version"] == None assert resource_versions_by_key["test_resource_no_config"] == join_and_hash( join_and_hash(), "42" )
def test_step_versions_with_resources(): run_config = {"resources": {"test_resource": {"config": {"input_str": "apple"}}}} speculative_execution_plan = create_execution_plan( versioned_modes_pipeline, run_config=run_config, mode="fakemode" ) versions = speculative_execution_plan.resolve_step_versions() solid_def_version = fake_solid_resources_versioned.version solid_config_version = resolve_config_version(None) resource_versions_by_key = resolve_resource_versions( speculative_execution_plan.environment_config, speculative_execution_plan.pipeline.get_definition(), ) solid_resources_version = join_and_hash( *[ resource_versions_by_key[resource_key] for resource_key in fake_solid_resources_versioned.required_resource_keys ] ) solid_version = join_and_hash(solid_def_version, solid_config_version, solid_resources_version) step_version = join_and_hash(solid_version) assert versions["fake_solid_resources_versioned"] == step_version
def basic_resource_versions(): run_config = { "resources": { "basic_resource": { "config": { "input_str": "apple" }, }, "resource_no_version": { "config": { "input_str": "banana" } }, } } resolved_run_config = ResolvedRunConfig.build(modes_pipeline, run_config, mode="fakemode") resource_versions_by_key = resolve_resource_versions( resolved_run_config, modes_pipeline) assert resource_versions_by_key["basic_resource"] == join_and_hash( resolve_config_version({"input_str": "apple"}), basic_resource.version) assert resource_versions_by_key["resource_no_version"] == None assert resource_versions_by_key["resource_no_config"] == join_and_hash( join_and_hash(), "42")
def test_resolve_step_versions_external_dependencies(): run_config = {"solids": {"versioned_solid_ext_input": {"inputs": {"custom_type": "a"}}}} speculative_execution_plan = create_execution_plan( versioned_pipeline_ext_input, run_config=run_config, ) versions = resolve_step_versions_for_test(speculative_execution_plan, run_config=run_config) ext_input_version = join_and_hash("a") input_version = join_and_hash(InputHydration.loader_version + ext_input_version) solid1_def_version = versioned_solid_ext_input.version solid1_config_version = resolve_config_version(None) solid1_resources_version = join_and_hash() solid1_version = join_and_hash( solid1_def_version, solid1_config_version, solid1_resources_version ) step1_version = join_and_hash(input_version, solid1_version) assert versions["versioned_solid_ext_input.compute"] == step1_version output_version = join_and_hash(step1_version, "result") hashed_input2 = join_and_hash(output_version) solid2_def_version = versioned_solid_takes_input.version solid2_config_version = resolve_config_version(None) solid2_resources_version = join_and_hash() solid2_version = join_and_hash( solid2_def_version, solid2_config_version, solid2_resources_version ) step2_version = join_and_hash(hashed_input2, solid2_version) assert versions["versioned_solid_takes_input.compute"] == step2_version
def test_resource_versions(): run_config = { "resources": { "test_resource": { "config": { "input_str": "apple" }, }, "test_resource_no_version": { "config": { "input_str": "banana" } }, } } environment_config = EnvironmentConfig.build( modes_pipeline, run_config=run_config, mode="fakemode", ) resource_versions_by_key = resolve_resource_versions( environment_config, modes_pipeline.get_mode_definition("fakemode")) assert resource_versions_by_key["test_resource"] == join_and_hash( resolve_config_version({"config": { "input_str": "apple" }}), test_resource.version) assert resource_versions_by_key["test_resource_no_version"] == None assert resource_versions_by_key[ "test_resource_no_config"] == join_and_hash(join_and_hash(), "42")
def test_join_and_hash(): assert join_and_hash("foo") == hashlib.sha1("foo".encode("utf-8")).hexdigest() assert join_and_hash("foo", None, "bar") == None assert join_and_hash("foo", "bar") == hashlib.sha1("barfoo".encode("utf-8")).hexdigest() assert join_and_hash("foo", "bar", "zab") == join_and_hash("zab", "bar", "foo")
def test_join_and_hash(): assert join_and_hash("foo") == hashlib.sha1(b"foo").hexdigest() assert join_and_hash("foo", None, "bar") == None assert join_and_hash("foo", "bar") == hashlib.sha1(b"barfoo").hexdigest() assert join_and_hash("foo", "bar", "zab") == join_and_hash("zab", "bar", "foo")
def versioned_pipeline_expected_step2_version(): solid2_def_version = versioned_solid_takes_input.version solid2_config_version = resolve_config_version(None) solid2_resources_version = join_and_hash() solid2_version = join_and_hash(solid2_def_version, solid2_config_version, solid2_resources_version) step1_outputs_hash = versioned_pipeline_expected_step1_output_version() step2_version = join_and_hash(step1_outputs_hash, solid2_version) return step2_version
def test_resolve_config_version(): assert resolve_config_version(None) == join_and_hash() assert resolve_config_version({}) == join_and_hash() assert resolve_config_version({ "a": "b", "c": "d" }) == join_and_hash("a" + join_and_hash("b"), "c" + join_and_hash("d")) assert resolve_config_version({ "a": "b", "c": "d" }) == resolve_config_version({ "c": "d", "a": "b" }) assert resolve_config_version({ "a": { "b": "c" }, "d": "e" }) == join_and_hash("a" + join_and_hash("b" + join_and_hash("c")), "d" + join_and_hash("e"))
def test_resolve_step_versions_no_external_dependencies(): speculative_execution_plan = create_execution_plan(versioned_pipeline) versions = resolve_step_versions(speculative_execution_plan) solid1_hash = join_and_hash([versioned_solid_no_input.version]) output1_hash = join_and_hash([solid1_hash + "result"]) outputs_hash = join_and_hash([output1_hash]) solid2_hash = join_and_hash([outputs_hash, versioned_solid_takes_input.version]) assert versions["versioned_solid_no_input.compute"] == solid1_hash assert versions["versioned_solid_takes_input.compute"] == solid2_hash
def run_test_with_builtin_type(type_to_test, loader_version, type_value): @solid(version="42", input_defs=[InputDefinition("_builtin_type", type_to_test)]) def versioned_solid_ext_input_builtin_type(_, _builtin_type): pass @pipeline def versioned_pipeline_ext_input_builtin_type(): return versioned_solid_takes_input( versioned_solid_ext_input_builtin_type()) run_config = { "solids": { "versioned_solid_ext_input_builtin_type": { "inputs": { "_builtin_type": type_value } } } } speculative_execution_plan = create_execution_plan( versioned_pipeline_ext_input_builtin_type, run_config=run_config, ) versions = resolve_step_versions_for_test(speculative_execution_plan, run_config=run_config) ext_input_version = join_and_hash(str(type_value)) input_version = join_and_hash(loader_version + ext_input_version) solid1_def_version = versioned_solid_ext_input_builtin_type.version solid1_config_version = resolve_config_version(None) solid1_resources_version = join_and_hash() solid1_version = join_and_hash(solid1_def_version, solid1_config_version, solid1_resources_version) step1_version = join_and_hash(input_version, solid1_version) assert versions[ "versioned_solid_ext_input_builtin_type.compute"] == step1_version output_version = join_and_hash(step1_version, "result") hashed_input2 = join_and_hash(output_version) solid2_def_version = versioned_solid_takes_input.version solid2_config_version = resolve_config_version(None) solid2_resources_version = join_and_hash() solid2_version = join_and_hash(solid2_def_version, solid2_config_version, solid2_resources_version) step2_version = join_and_hash(hashed_input2, solid2_version) assert versions["versioned_solid_takes_input.compute"] == step2_version
def test_resolve_step_versions_default_value(): speculative_execution_plan = create_execution_plan(versioned_pipeline_default_value) versions = speculative_execution_plan.resolve_step_versions() input_version = join_and_hash(repr("DEFAULTVAL")) solid_def_version = versioned_solid_default_value.version solid_config_version = resolve_config_version(None) solid_resources_version = join_and_hash() solid_version = join_and_hash(solid_def_version, solid_config_version, solid_resources_version) step_version = join_and_hash(input_version, solid_version) assert versions["versioned_solid_default_value"] == step_version
def test_resolve_step_versions_default_value(): speculative_execution_plan = create_execution_plan(versioned_pipeline_default_value) versions = resolve_step_versions_for_test(speculative_execution_plan) default_val_version = join_and_hash("DEFAULTVAL") input_version = join_and_hash(InputHydration.loader_version + default_val_version) solid_def_version = versioned_solid_ext_input.version solid_config_version = resolve_config_version(None) solid_resources_version = join_and_hash() solid_version = join_and_hash(solid_def_version, solid_config_version, solid_resources_version) step_version = join_and_hash(input_version, solid_version) assert versions["versioned_solid_default_value.compute"] == step_version
def test_resolve_step_versions_default_value(): speculative_execution_plan = create_execution_plan( versioned_pipeline_default_value) versions = resolve_step_versions_for_test(speculative_execution_plan) default_val_version = join_and_hash("DEFAULTVAL") input_version = join_and_hash( "String" + default_val_version ) # Since we use the type name as the loader version for default types. solid_def_version = versioned_solid_default_value.version solid_config_version = resolve_config_version(None) solid_resources_version = join_and_hash() solid_version = join_and_hash(solid_def_version, solid_config_version, solid_resources_version) step_version = join_and_hash(input_version, solid_version) assert versions["versioned_solid_default_value.compute"] == step_version
def test_step_versions_with_resources(): run_config = { "resources": { "basic_resource": { "config": { "input_str": "apple" } } } } speculative_execution_plan = create_execution_plan( versioned_modes_pipeline, run_config=run_config, mode="fakemode") resolved_run_config = ResolvedRunConfig.build(versioned_modes_pipeline, run_config=run_config, mode="fakemode") versions = resolve_step_versions(versioned_modes_pipeline, speculative_execution_plan, resolved_run_config) solid_def_version = fake_solid_resources_versioned.version solid_config_version = resolve_config_version(None) resolved_run_config = ResolvedRunConfig.build(versioned_modes_pipeline, run_config, mode="fakemode") resource_versions_by_key = resolve_resource_versions( resolved_run_config, versioned_modes_pipeline, ) solid_resources_version = join_and_hash(*[ resource_versions_by_key[resource_key] for resource_key in fake_solid_resources_versioned.required_resource_keys ]) solid_version = join_and_hash(solid_def_version, solid_config_version, solid_resources_version) step_version = join_and_hash(solid_version) assert versions["fake_solid_resources_versioned"] == step_version
def test_resolve_config_version(): assert resolve_config_version({}) == join_and_hash([]) assert resolve_config_version({"a": "b", "c": "d"}) == join_and_hash( ["a" + join_and_hash(["b"]), "c" + join_and_hash(["d"])] ) assert resolve_config_version({"a": "b", "c": "d"}) == resolve_config_version( {"c": "d", "a": "b"} ) assert resolve_config_version({"a": {"b": "c"}, "d": "e"}) == join_and_hash( ["a" + join_and_hash(["b" + join_and_hash(["c"])]), "d" + join_and_hash(["e"])] )
def test_step_versions_separate_io_manager(): mgr = io_manager_factory(VersionedInMemoryIOManager()) @solid(version="39", output_defs=[OutputDefinition(io_manager_key="fake")]) def solid_requires_io_manager(): return Output(5) @pipeline(mode_defs=[ ModeDefinition( name="fakemode", resource_defs={ "fake": mgr, }, ), ]) def io_mgr_pipeline(): solid_requires_io_manager() speculative_execution_plan = create_execution_plan(io_mgr_pipeline, run_config={}, mode="fakemode") resolved_run_config = ResolvedRunConfig.build(io_mgr_pipeline, run_config={}, mode="fakemode") versions = resolve_step_versions(io_mgr_pipeline, speculative_execution_plan, resolved_run_config) solid_def_version = fake_solid_resources_versioned.version solid_config_version = resolve_config_version(None) solid_resources_version = join_and_hash(*[]) solid_version = join_and_hash(solid_def_version, solid_config_version, solid_resources_version) step_version = join_and_hash(solid_version) assert versions["solid_requires_io_manager"] == step_version
def resolve_unmemoized_steps(self, speculative_execution_plan, step_versions): unmemoized_steps = [] for step in speculative_execution_plan.topological_steps(): step_version = step_versions[step.key] output_versions = [ join_and_hash([name, step_version]) for name in step.step_output_dict.keys() ] addresses = _fake_output_address( output_versions ) # TODO: replace with real version storage once that has landed. if any([not version in addresses for version in output_versions]): unmemoized_steps.append(step.key) return unmemoized_steps
def test_resolve_step_versions_external_dependencies(): speculative_execution_plan = create_execution_plan( versioned_pipeline_ext_input, run_config={"solids": {"versioned_solid_ext_input": {"inputs": {"custom_type": "a"}}}}, ) versions = resolve_step_versions(speculative_execution_plan) ext_input_version = join_and_hash(["a"]) input_version = join_and_hash([InputHydration.loader_version + ext_input_version]) step_version1 = join_and_hash([input_version, versioned_solid_ext_input.version]) assert versions["versioned_solid_ext_input.compute"] == step_version1 output_version = join_and_hash([step_version1, "result"]) hashed_input2 = join_and_hash([output_version]) step_version2 = join_and_hash([hashed_input2, versioned_solid_takes_input.version]) assert versions["versioned_solid_takes_input.compute"] == step_version2
def _get_ext_version(config_value): return join_and_hash(str(config_value))
def versioned_pipeline_expected_step2_output_version(): step2_version = versioned_pipeline_expected_step2_version() return join_and_hash(step2_version + "result")
def _external_version_fn(val): from dagster.core.execution.resolve_versions import join_and_hash return join_and_hash(str(val), )