spinedb_api.import_functions ============================ .. py:module:: spinedb_api.import_functions .. autoapi-nested-parse:: Functions for importing data into a Spine database in a standard format. This functionality is equivalent to the one provided by :meth:`.DatabaseMapping.add_update_item`, but the syntax is a little more compact. Functions --------- .. autoapisummary:: spinedb_api.import_functions.import_data spinedb_api.import_functions.get_data_for_import spinedb_api.import_functions.import_superclass_subclasses spinedb_api.import_functions.import_entity_classes spinedb_api.import_functions.import_entities spinedb_api.import_functions.import_entity_alternatives spinedb_api.import_functions.import_entity_groups spinedb_api.import_functions.import_parameter_definitions spinedb_api.import_functions.import_parameter_types spinedb_api.import_functions.import_parameter_values spinedb_api.import_functions.import_alternatives spinedb_api.import_functions.import_scenarios spinedb_api.import_functions.import_display_modes spinedb_api.import_functions.import_entity_class_display_modes spinedb_api.import_functions.import_scenario_alternatives spinedb_api.import_functions.import_parameter_value_lists spinedb_api.import_functions.import_parameter_groups spinedb_api.import_functions.import_metadata spinedb_api.import_functions.import_entity_metadata spinedb_api.import_functions.import_parameter_value_metadata Module Contents --------------- .. py:function:: import_data(db_map: spinedb_api.DatabaseMapping, unparse_value: UnparseCallable = to_database, on_conflict: spinedb_api.parameter_value.ConflictResolution = 'merge', **kwargs) -> tuple[int, list[str]] Imports data into a Spine database using a standard format. Example:: entity_classes = [ ('example_class', ()), ('other_class', ()), ('multi_d_class', ('example_class', 'other_class')) ] alternatives = [('example_alternative', 'An example')] scenarios = [('example_scenario', 'An example')] scenario_alternatives = [ ('example_scenario', 'example_alternative'), ('example_scenario', 'Base', 'example_alternative') ] parameter_value_lists = [("example_list", "value1"), ("example_list", "value2")] parameter_definitions = [('example_class', 'example_parameter'), ('multi_d_class', 'other_parameter')] entities = [ ('example_class', 'example_entity'), ('example_class', 'example_group'), ('example_class', 'example_member'), ('other_class', 'other_entity'), ('multi_d_class', ('example_entity', 'other_entity')), ] entity_groups = [ ('example_class', 'example_group', 'example_member'), ('example_class', 'example_group', 'example_entity'), ] parameter_values = [ ('example_object_class', 'example_entity', 'example_parameter', 3.14), ('multi_d_class', ('example_entity', 'other_entity'), 'rel_parameter', 2.718), ] entity_alternatives = [ ('example_class', 'example_entity', "example_alternative", True), ('example_class', 'example_entity', "example_alternative", False), ] import_data( db_map, entity_classes=entity_classes, alternatives=alternatives, scenarios=scenarios, scenario_alternatives=scenario_alternatives, parameter_value_lists=parameter_value_lists, parameter_definitions=parameter_definitions, entities=entities, entity_groups=entity_groups, parameter_values=parameter_values, entity_alternatives=entity_alternatives, ) :param db_map: database mapping :param unparse_value: function to call to parse parameter values :param on_conflict: Conflict resolution strategy for :func:`parameter_value.fix_conflict` :param \*\*kwargs: data to import :returns: number of items imported and list of errors .. py:function:: get_data_for_import(db_map: spinedb_api.DatabaseMapping, all_errors: list[str], unparse_value: UnparseCallable = to_database, fix_value_conflict: spinedb_api.parameter_value.ConflictResolutionCallable = get_conflict_fixer('merge'), entity_classes: collections.abc.Iterable[EntityClass] = (), entities: collections.abc.Iterable[Entity] = (), entity_groups: collections.abc.Iterable[EntityGroup] = (), entity_alternatives: collections.abc.Iterable[EntityAlternative] = (), parameter_definitions: collections.abc.Iterable[ParameterDefinition] = (), parameter_types: collections.abc.Iterable[ParameterType] = (), parameter_values: collections.abc.Iterable[ParameterValue] = (), parameter_value_lists: collections.abc.Iterable[ParameterValueList] = (), parameter_groups: collections.abc.Iterable[ParameterGroup] = (), alternatives: collections.abc.Iterable[Alternative] = (), scenarios: collections.abc.Iterable[Scenario] = (), scenario_alternatives: collections.abc.Iterable[ScenarioAlternative] = (), metadata: collections.abc.Iterable[Metadata] = (), entity_metadata: collections.abc.Iterable[EntityMetadata] = (), parameter_value_metadata: collections.abc.Iterable[ParameterValueMetadata] = (), superclass_subclasses: collections.abc.Iterable[SuperclassSubclass] = (), display_modes: collections.abc.Iterable[DisplayMode] = (), entity_class_display_modes: collections.abc.Iterable[EntityClassDisplayMode] = (), object_classes=(), relationship_classes=(), object_parameters=(), relationship_parameters=(), objects=(), relationships=(), object_groups=(), object_parameter_values=(), relationship_parameter_values=(), object_metadata=(), relationship_metadata=(), object_parameter_value_metadata=(), relationship_parameter_value_metadata=(), tools=(), features=(), tool_features=(), tool_feature_methods=()) -> collections.abc.Iterator[tuple[spinedb_api.helpers.ItemType, collections.abc.Iterable[dict]]] Yields data to import into a Spine DB. :param db_map: database mapping :param all_errors: errors encountered during import :param unparse_value: function to call when parsing parameter values :param fix_value_conflict: parameter value conflict resolution function :param entity_classes: entity class tuples :param parameter_definitions: tuples of parameter definitions :param parameter_types: tuples of parameter types :param parameter_groups: tuples of parameter groups :param entities: tuples of entities :param entity_alternatives: tuples of entity alternatives :param entity_groups: tuples of entity groups :param parameter_values: tuples of parameter values :param alternatives: tuples of alternatives :param scenarios: tuples of scenarios :param scenario_alternatives: tuples of scenario alternatives :param parameter_value_lists: tuples of parameter value lists :param metadata: tuples of metadata :param entity_metadata: tuples of entity metadata :param parameter_value_metadata: tuples of parameter value metadata :param superclass_subclasses: tuples of superclass subclasses :param display_modes: tuples of display modes :param entity_class_display_modes: tuples of entity class display modes :Yields: tuple of (item type, item dicts) .. py:function:: import_superclass_subclasses(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[SuperclassSubclass]) -> tuple[int, list[str]] Imports superclass_subclasses into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (superclass name, subclass name) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_entity_classes(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[EntityClass]) -> tuple[int, list[str]] Imports entity classes into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (name, [(dimension 1 name, dimension 2 name ,...)], [description], [display icon integer], [active by default]) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_entities(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[Entity]) -> tuple[int, list[str]] Imports entities into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (class name, entity name or byname, [description], [location]) where location is a tuple of (latitude, longitude, altitude, shape name, shape GEOJSON) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_entity_alternatives(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[EntityAlternative]) -> tuple[int, list[str]] Imports entity alternatives into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (class name, entity name or byname, alternative name, activity) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_entity_groups(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[EntityGroup]) -> tuple[int, list[str]] Imports entity groups into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (class name, group entity name, member entity name) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_parameter_definitions(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[ParameterDefinition], unparse_value: UnparseCallable = to_database) -> tuple[int, list[str]] Imports parameter definitions into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (class name, parameter name, [default value], [parameter value list name], [description], [parameter group name]) :param unparse_value: function to parse parameter values :returns: tuple of (number of items imported, list of errors) .. py:function:: import_parameter_types(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[ParameterType], unparse_value: UnparseCallable = to_database) -> tuple[int, list[str]] Imports parameter types into a Spine database using a standard format. :param db_map: database mapping :param data: tuple of (class name, parameter name, type, [succeeding type]) :param unparse_value: function to parse parameter values :returns: tuple of (number of items imported, list of errors) .. py:function:: import_parameter_values(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[ParameterValue], unparse_value: UnparseCallable = to_database, on_conflict: spinedb_api.parameter_value.ConflictResolution = 'merge') -> tuple[int, list[str]] Imports parameter values into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (class name, entity name or byname, parameter definition name, value, [alternative_name]) :param unparse_value: function to parse parameter values :param on_conflict: Conflict resolution strategy; options: "keep", "replace", "merge" :returns: tuple of (number of items imported, list of errors) .. py:function:: import_alternatives(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[Alternative]) -> tuple[int, list[str]] Imports alternatives into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (name, [description]) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_scenarios(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[Scenario]) -> tuple[int, list[str]] Imports scenarios into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (name, [], [description]) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_display_modes(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[DisplayMode]) -> tuple[int, list[str]] Imports display modes into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (name, [description]) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_entity_class_display_modes(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[EntityClassDisplayMode]) -> tuple[int, list[str]] Imports entity class display modes into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (display mode name, entity class name, display order) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_scenario_alternatives(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[ScenarioAlternative]) -> tuple[int, list[str]] Imports scenario alternatives into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (scenario, alternative, [succeeding alternative]) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_parameter_value_lists(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[ParameterValueList], unparse_value: UnparseCallable = to_database) -> tuple[int, list[str]] Imports parameter value lists into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (list name, value) :param unparse_value: function to parse parameter values :returns: tuple of (number of items imported, list of errors) .. py:function:: import_parameter_groups(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[ParameterGroup]) -> tuple[int, list[str]] Imports parameter groups into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (group name, color as 6-digit HEX value) :returns: tuple of (number of groups imported, list of errors) .. py:function:: import_metadata(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[Metadata]) -> tuple[int, list[str]] Imports metadata into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (entry name, value) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_entity_metadata(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[EntityMetadata]) -> tuple[int, list[str]] Imports metadata into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (entity class name, entity (by)name, metadata name, metadata value) :returns: tuple of (number of items imported, list of errors) .. py:function:: import_parameter_value_metadata(db_map: spinedb_api.DatabaseMapping, data: collections.abc.Iterable[ParameterValueMetadata]) -> tuple[int, list[str]] Imports metadata into a Spine database using a standard format. :param db_map: database mapping :param data: tuples of (entity class name, entity (by)name, parameter_name, metadata name, metadata value, [alternative name]) :returns: tuple of (number of items imported, list of errors)