biocypher 0.5.39__py3-none-any.whl → 0.5.41__py3-none-any.whl

biocypher/{_write.py → write/_batch_writer.py}

@@ -1,41 +1,17 @@
-#!/usr/bin/env python
-
-#
-# Copyright 2021, Heidelberg University Clinic
-#
-# File author(s): Sebastian Lobentanzer
-#                 Michael Hartung
-#
-# Distributed under MIT licence, see the file `LICENSE`.
-#
-"""
-BioCypher 'offline' module. Handles the writing of node and edge representations
-suitable for import into a DBMS.
-"""
-
-import re
-import glob
-
-from ._logger import logger
-
-logger.debug(f"Loading module {__name__}.")
-
 from abc import ABC, abstractmethod
 from types import GeneratorType
-from typing import TYPE_CHECKING, Union, Optional
+from typing import Union, Optional
 from collections import OrderedDict, defaultdict
 import os
+import re
+import glob
 
 from more_itertools import peekable
 
-from ._config import config as _config
-from ._create import BioCypherEdge, BioCypherNode, BioCypherRelAsNode
-
-__all__ = ["get_writer"]
-
-if TYPE_CHECKING:
-    from ._translate import Translator
-    from ._deduplicate import Deduplicator
+from biocypher._create import BioCypherEdge, BioCypherNode, BioCypherRelAsNode
+from biocypher._logger import logger
+from biocypher._translate import Translator
+from biocypher._deduplicate import Deduplicator
 
 
 class _BatchWriter(ABC):
@@ -1026,295 +1002,6 @@ class _BatchWriter(ABC):
         return file_path
 
 
-class _Neo4jBatchWriter(_BatchWriter):
-    """
-    Class for writing node and edge representations to disk using the
-    format specified by Neo4j for the use of admin import. Each batch
-    writer instance has a fixed representation that needs to be passed
-    at instantiation via the :py:attr:`schema` argument. The instance
-    also expects an ontology adapter via :py:attr:`ontology_adapter` to be able
-    to convert and extend the hierarchy.
-
-    This class inherits from the abstract class "_BatchWriter" and implements the
-    Neo4j-specific methods:
-
-        - _write_node_headers
-        - _write_edge_headers
-        - _construct_import_call
-        - _write_array_string
-    """
-
-    def _get_default_import_call_bin_prefix(self):
-        """
-        Method to provide the default string for the import call bin prefix.
-
-        Returns:
-            str: The default location for the neo4j admin import location
-        """
-        return "bin/"
-
-    def _write_array_string(self, string_list):
-        """
-        Abstract method to write the string representation of an array into a .csv file
-        as required by the neo4j admin-import.
-
-        Args:
-            string_list (list): list of ontology strings
-
-        Returns:
-            str: The string representation of an array for the neo4j admin import
-        """
-        string = self.adelim.join(string_list)
-        return f"{self.quote}{string}{self.quote}"
-
-    def _write_node_headers(self):
-        """
-        Writes single CSV file for a graph entity that is represented
-        as a node as per the definition in the `schema_config.yaml`,
-        containing only the header for this type of node.
-
-        Returns:
-            bool: The return value. True for success, False otherwise.
-        """
-        # load headers from data parse
-        if not self.node_property_dict:
-            logger.error(
-                "Header information not found. Was the data parsed first?",
-            )
-            return False
-
-        for label, props in self.node_property_dict.items():
-            _id = ":ID"
-
-            # translate label to PascalCase
-            pascal_label = self.translator.name_sentence_to_pascal(
-                parse_label(label)
-            )
-
-            header = f"{pascal_label}-header.csv"
-            header_path = os.path.join(
-                self.outdir,
-                header,
-            )
-            parts = f"{pascal_label}-part.*"
-
-            # check if file already exists
-            if os.path.exists(header_path):
-                logger.warning(
-                    f"Header file `{header_path}` already exists. Overwriting.",
-                )
-
-            # concatenate key:value in props
-            props_list = []
-            for k, v in props.items():
-                if v in ["int", "long", "integer"]:
-                    props_list.append(f"{k}:long")
-                elif v in ["int[]", "long[]", "integer[]"]:
-                    props_list.append(f"{k}:long[]")
-                elif v in ["float", "double", "dbl"]:
-                    props_list.append(f"{k}:double")
-                elif v in ["float[]", "double[]"]:
-                    props_list.append(f"{k}:double[]")
-                elif v in ["bool", "boolean"]:
-                    # TODO Neo4j boolean support / spelling?
-                    props_list.append(f"{k}:boolean")
-                elif v in ["bool[]", "boolean[]"]:
-                    props_list.append(f"{k}:boolean[]")
-                elif v in ["str[]", "string[]"]:
-                    props_list.append(f"{k}:string[]")
-                else:
-                    props_list.append(f"{k}")
-
-            # create list of lists and flatten
-            out_list = [[_id], props_list, [":LABEL"]]
-            out_list = [val for sublist in out_list for val in sublist]
-
-            with open(header_path, "w", encoding="utf-8") as f:
-                # concatenate with delimiter
-                row = self.delim.join(out_list)
-                f.write(row)
-
-            # add file path to neo4 admin import statement (import call file
-            # path may be different from actual file path)
-            import_call_header_path = os.path.join(
-                self.import_call_file_prefix,
-                header,
-            )
-            import_call_parts_path = os.path.join(
-                self.import_call_file_prefix,
-                parts,
-            )
-            self.import_call_nodes.add(
-                (import_call_header_path, import_call_parts_path)
-            )
-
-        return True
-
-    def _write_edge_headers(self):
-        """
-        Writes single CSV file for a graph entity that is represented
-        as an edge as per the definition in the `schema_config.yaml`,
-        containing only the header for this type of edge.
-
-        Returns:
-            bool: The return value. True for success, False otherwise.
-        """
-        # load headers from data parse
-        if not self.edge_property_dict:
-            logger.error(
-                "Header information not found. Was the data parsed first?",
-            )
-            return False
-
-        for label, props in self.edge_property_dict.items():
-            # translate label to PascalCase
-            pascal_label = self.translator.name_sentence_to_pascal(
-                parse_label(label)
-            )
-
-            # paths
-            header = f"{pascal_label}-header.csv"
-            header_path = os.path.join(
-                self.outdir,
-                header,
-            )
-            parts = f"{pascal_label}-part.*"
-
-            # check for file exists
-            if os.path.exists(header_path):
-                logger.warning(
-                    f"File {header_path} already exists. Overwriting."
-                )
-
-            # concatenate key:value in props
-            props_list = []
-            for k, v in props.items():
-                if v in ["int", "long", "integer"]:
-                    props_list.append(f"{k}:long")
-                elif v in ["int[]", "long[]", "integer[]"]:
-                    props_list.append(f"{k}:long[]")
-                elif v in ["float", "double"]:
-                    props_list.append(f"{k}:double")
-                elif v in ["float[]", "double[]"]:
-                    props_list.append(f"{k}:double[]")
-                elif v in [
-                    "bool",
-                    "boolean",
-                ]:  # TODO does Neo4j support bool?
-                    props_list.append(f"{k}:boolean")
-                elif v in ["bool[]", "boolean[]"]:
-                    props_list.append(f"{k}:boolean[]")
-                elif v in ["str[]", "string[]"]:
-                    props_list.append(f"{k}:string[]")
-                else:
-                    props_list.append(f"{k}")
-
-            skip_id = False
-            schema_label = None
-
-            if label in ["IS_SOURCE_OF", "IS_TARGET_OF", "IS_PART_OF"]:
-                skip_id = True
-            elif not self.translator.ontology.mapping.extended_schema.get(
-                label
-            ):
-                # find label in schema by label_as_edge
-                for (
-                    k,
-                    v,
-                ) in self.translator.ontology.mapping.extended_schema.items():
-                    if v.get("label_as_edge") == label:
-                        schema_label = k
-                        break
-            else:
-                schema_label = label
-
-            out_list = [":START_ID"]
-
-            if schema_label:
-                if (
-                    self.translator.ontology.mapping.extended_schema.get(
-                        schema_label
-                    ).get("use_id")
-                    == False
-                ):
-                    skip_id = True
-
-            if not skip_id:
-                out_list.append("id")
-
-            out_list.extend(props_list)
-            out_list.extend([":END_ID", ":TYPE"])
-
-            with open(header_path, "w", encoding="utf-8") as f:
-                # concatenate with delimiter
-                row = self.delim.join(out_list)
-                f.write(row)
-
-            # add file path to neo4 admin import statement (import call file
-            # path may be different from actual file path)
-            import_call_header_path = os.path.join(
-                self.import_call_file_prefix,
-                header,
-            )
-            import_call_parts_path = os.path.join(
-                self.import_call_file_prefix,
-                parts,
-            )
-            self.import_call_edges.add(
-                (import_call_header_path, import_call_parts_path)
-            )
-
-        return True
-
-    def _get_import_script_name(self) -> str:
-        """
-        Returns the name of the neo4j admin import script
-
-        Returns:
-            str: The name of the import script (ending in .sh)
-        """
-        return "neo4j-admin-import-call.sh"
-
-    def _construct_import_call(self) -> str:
-        """
-        Function to construct the import call detailing folder and
-        individual node and edge headers and data files, as well as
-        delimiters and database name. Built after all data has been
-        processed to ensure that nodes are called before any edges.
-
-        Returns:
-            str: a bash command for neo4j-admin import
-        """
-        import_call = (
-            f"{self.import_call_bin_prefix}neo4j-admin import "
-            f"--database={self.db_name} "
-            f'--delimiter="{self.escaped_delim}" '
-            f'--array-delimiter="{self.escaped_adelim}" '
-        )
-
-        if self.quote == "'":
-            import_call += f'--quote="{self.quote}" '
-        else:
-            import_call += f"--quote='{self.quote}' "
-
-        if self.wipe:
-            import_call += f"--force=true "
-        if self.skip_bad_relationships:
-            import_call += "--skip-bad-relationships=true "
-        if self.skip_duplicate_nodes:
-            import_call += "--skip-duplicate-nodes=true "
-
-        # append node import calls
-        for header_path, parts_path in self.import_call_nodes:
-            import_call += f'--nodes="{header_path},{parts_path}" '
-
-        # append edge import calls
-        for header_path, parts_path in self.import_call_edges:
-            import_call += f'--relationships="{header_path},{parts_path}" '
-
-        return import_call
-
-
 def parse_label(label: str) -> str:
     """
 
@@ -1350,627 +1037,3 @@ def parse_label(label: str) -> str:
             "Label does not start with an alphabetic character or with $. Removed non compliant characters."
         )
     return "".join(matches).strip()
-
-
-class _ArangoDBBatchWriter(_Neo4jBatchWriter):
-    """
-    Class for writing node and edge representations to disk using the format
-    specified by ArangoDB for the use of "arangoimport". Output files are
-    similar to Neo4j, but with a different header format.
-    """
-
-    def _get_default_import_call_bin_prefix(self):
-        """
-        Method to provide the default string for the import call bin prefix.
-
-        Returns:
-            str: The default location for the neo4j admin import location
-        """
-        return ""
-
-    def _get_import_script_name(self) -> str:
-        """
-        Returns the name of the neo4j admin import script
-
-        Returns:
-            str: The name of the import script (ending in .sh)
-        """
-        return "arangodb-import-call.sh"
-
-    def _write_node_headers(self):
-        """
-        Writes single CSV file for a graph entity that is represented
-        as a node as per the definition in the `schema_config.yaml`,
-        containing only the header for this type of node.
-
-        Returns:
-            bool: The return value. True for success, False otherwise.
-        """
-        # load headers from data parse
-        if not self.node_property_dict:
-            logger.error(
-                "Header information not found. Was the data parsed first?",
-            )
-            return False
-
-        for label, props in self.node_property_dict.items():
-            # create header CSV with ID, properties, labels
-
-            _id = "_key"
-
-            # translate label to PascalCase
-            pascal_label = self.translator.name_sentence_to_pascal(label)
-
-            header = f"{pascal_label}-header.csv"
-            header_path = os.path.join(
-                self.outdir,
-                header,
-            )
-
-            # check if file already exists
-            if os.path.exists(header_path):
-                logger.warning(
-                    f"File {header_path} already exists. Overwriting."
-                )
-
-            # concatenate key:value in props
-            props_list = []
-            for k in props.keys():
-                props_list.append(f"{k}")
-
-            # create list of lists and flatten
-            # removes need for empty check of property list
-            out_list = [[_id], props_list]
-            out_list = [val for sublist in out_list for val in sublist]
-
-            with open(header_path, "w", encoding="utf-8") as f:
-                # concatenate with delimiter
-                row = self.delim.join(out_list)
-                f.write(row)
-
-            # add collection from schema config
-            collection = self.translator.ontology.mapping.extended_schema[
-                label
-            ].get("db_collection_name", None)
-
-            # add file path to neo4 admin import statement
-            # do once for each part file
-            parts = self.parts.get(label, [])
-
-            if not parts:
-                raise ValueError(
-                    f"No parts found for node label {label}. "
-                    f"Check that the data was parsed first.",
-                )
-
-            for part in parts:
-                import_call_header_path = os.path.join(
-                    self.import_call_file_prefix,
-                    header,
-                )
-                import_call_parts_path = os.path.join(
-                    self.import_call_file_prefix,
-                    part,
-                )
-
-                self.import_call_nodes.add(
-                    (
-                        import_call_header_path,
-                        import_call_parts_path,
-                        collection,
-                    )
-                )
-
-        return True
-
-    def _write_edge_headers(self):
-        """
-        Writes single CSV file for a graph entity that is represented
-        as an edge as per the definition in the `schema_config.yaml`,
-        containing only the header for this type of edge.
-
-        Returns:
-            bool: The return value. True for success, False otherwise.
-        """
-        # load headers from data parse
-        if not self.edge_property_dict:
-            logger.error(
-                "Header information not found. Was the data parsed first?",
-            )
-            return False
-
-        for label, props in self.edge_property_dict.items():
-            # translate label to PascalCase
-            pascal_label = self.translator.name_sentence_to_pascal(label)
-
-            # paths
-            header = f"{pascal_label}-header.csv"
-            header_path = os.path.join(
-                self.outdir,
-                header,
-            )
-            parts = f"{pascal_label}-part.*"
-
-            # check for file exists
-            if os.path.exists(header_path):
-                logger.warning(
-                    f"Header file {header_path} already exists. Overwriting."
-                )
-
-            # concatenate key:value in props
-            props_list = []
-            for k in props.keys():
-                props_list.append(f"{k}")
-
-            out_list = ["_from", "_key", *props_list, "_to"]
-
-            with open(header_path, "w", encoding="utf-8") as f:
-                # concatenate with delimiter
-                row = self.delim.join(out_list)
-                f.write(row)
-
-            # add collection from schema config
-            if not self.translator.ontology.mapping.extended_schema.get(label):
-                for (
-                    _,
-                    v,
-                ) in self.translator.ontology.mapping.extended_schema.items():
-                    if v.get("label_as_edge") == label:
-                        collection = v.get("db_collection_name", None)
-                        break
-
-            else:
-                collection = self.translator.ontology.mapping.extended_schema[
-                    label
-                ].get("db_collection_name", None)
-
-            # add file path to neo4 admin import statement (import call path
-            # may be different from actual output path)
-            header_import_call_path = os.path.join(
-                self.import_call_file_prefix,
-                header,
-            )
-            parts_import_call_path = os.path.join(
-                self.import_call_file_prefix,
-                parts,
-            )
-            self.import_call_edges.add(
-                (
-                    header_import_call_path,
-                    parts_import_call_path,
-                    collection,
-                )
-            )
-
-        return True
-
-    def _construct_import_call(self) -> str:
-        """
-        Function to construct the import call detailing folder and
-        individual node and edge headers and data files, as well as
-        delimiters and database name. Built after all data has been
-        processed to ensure that nodes are called before any edges.
-
-        Returns:
-            str: a bash command for neo4j-admin import
-        """
-        import_call = (
-            f"{self.import_call_bin_prefix}arangoimp "
-            f"--type csv "
-            f'--separator="{self.escaped_delim}" '
-        )
-
-        if self.quote == "'":
-            import_call += f'--quote="{self.quote}" '
-        else:
-            import_call += f"--quote='{self.quote}' "
-
-        node_lines = ""
-
-        # node import calls: one line per node type
-        for header_path, parts_path, collection in self.import_call_nodes:
-            line = (
-                f"{import_call} "
-                f"--headers-file {header_path} "
-                f"--file= {parts_path} "
-            )
-
-            if collection:
-                line += f"--create-collection --collection {collection} "
-
-            node_lines += f"{line}\n"
-
-        edge_lines = ""
-
-        # edge import calls: one line per edge type
-        for header_path, parts_path, collection in self.import_call_edges:
-            import_call += f'--relationships="{header_path},{parts_path}" '
-
-        return node_lines + edge_lines
-
-
-class _PostgreSQLBatchWriter(_BatchWriter):
-    """
-    Class for writing node and edge representations to disk using the
-    format specified by PostgreSQL for the use of "COPY FROM...". Each batch
-    writer instance has a fixed representation that needs to be passed
-    at instantiation via the :py:attr:`schema` argument. The instance
-    also expects an ontology adapter via :py:attr:`ontology_adapter` to be able
-    to convert and extend the hierarchy.
-
-    This class inherits from the abstract class "_BatchWriter" and implements the
-    PostgreSQL-specific methods:
-
-        - _write_node_headers
-        - _write_edge_headers
-        - _construct_import_call
-        - _write_array_string
-    """
-
-    DATA_TYPE_LOOKUP = {
-        "str": "VARCHAR",  # VARCHAR needs limit
-        "int": "INTEGER",
-        "long": "BIGINT",
-        "float": "NUMERIC",
-        "double": "NUMERIC",
-        "dbl": "NUMERIC",
-        "boolean": "BOOLEAN",
-        "str[]": "VARCHAR[]",
-        "string[]": "VARCHAR[]",
-    }
-
-    def __init__(self, *args, **kwargs):
-        self._copy_from_csv_commands = set()
-        super().__init__(*args, **kwargs)
-
-    def _get_default_import_call_bin_prefix(self):
-        """
-        Method to provide the default string for the import call bin prefix.
-
-        Returns:
-            str: The default location for the psql command
-        """
-        return ""
-
-    def _get_data_type(self, string) -> str:
-        try:
-            return self.DATA_TYPE_LOOKUP[string]
-        except KeyError:
-            logger.info(
-                'Could not determine data type {string}. Using default "VARCHAR"'
-            )
-            return "VARCHAR"
-
-    def _write_array_string(self, string_list) -> str:
-        """
-        Abstract method to write the string representation of an array into a .csv file
-        as required by the postgresql COPY command, with '{','}' brackets and ',' separation.
-
-        Args:
-            string_list (list): list of ontology strings
-
-        Returns:
-            str: The string representation of an array for postgres COPY
-        """
-        string = ",".join(string_list)
-        string = f'"{{{string}}}"'
-        return string
-
-    def _get_import_script_name(self) -> str:
-        """
-        Returns the name of the psql import script
-
-        Returns:
-            str: The name of the import script (ending in .sh)
-        """
-        return f"{self.db_name}-import-call.sh"
-
-    def _adjust_pascal_to_psql(self, string):
-        string = string.replace(".", "_")
-        string = string.lower()
-        return string
-
-    def _write_node_headers(self):
-        """
-        Writes single CSV file for a graph entity that is represented
-        as a node as per the definition in the `schema_config.yaml`,
-        containing only the header for this type of node.
-
-        Returns:
-            bool: The return value. True for success, False otherwise.
-        """
-        # load headers from data parse
-        if not self.node_property_dict:
-            logger.error(
-                "Header information not found. Was the data parsed first?",
-            )
-            return False
-
-        for label, props in self.node_property_dict.items():
-            # create header CSV with ID, properties, labels
-
-            # translate label to PascalCase
-            pascal_label = self.translator.name_sentence_to_pascal(label)
-
-            parts = f"{pascal_label}-part*.csv"
-            parts_paths = os.path.join(self.outdir, parts)
-            parts_paths = glob.glob(parts_paths)
-            parts_paths.sort()
-
-            # adjust label for import to psql
-            pascal_label = self._adjust_pascal_to_psql(pascal_label)
-            table_create_command_path = os.path.join(
-                self.outdir,
-                f"{pascal_label}-create_table.sql",
-            )
-
-            # check if file already exists
-            if os.path.exists(table_create_command_path):
-                logger.warning(
-                    f"File {table_create_command_path} already exists. Overwriting.",
-                )
-
-            # concatenate key:value in props
-            columns = ["_ID VARCHAR"]
-            for col_name, col_type in props.items():
-                col_type = self._get_data_type(col_type)
-                col_name = self._adjust_pascal_to_psql(col_name)
-                columns.append(f"{col_name} {col_type}")
-            columns.append("_LABEL VARCHAR[]")
-
-            with open(table_create_command_path, "w", encoding="utf-8") as f:
-                command = ""
-                if self.wipe:
-                    command += f"DROP TABLE IF EXISTS {pascal_label};\n"
-
-                # table creation requires comma separation
-                command += (
-                    f'CREATE TABLE {pascal_label}({",".join(columns)});\n'
-                )
-                f.write(command)
-
-                for parts_path in parts_paths:
-                    # if import_call_file_prefix is set, replace actual path
-                    # with prefix
-                    if self.import_call_file_prefix != self.outdir:
-                        parts_path = parts_path.replace(
-                            self.outdir,
-                            self.import_call_file_prefix,
-                        )
-
-                    self._copy_from_csv_commands.add(
-                        f"\\copy {pascal_label} FROM '{parts_path}' DELIMITER E'{self.delim}' CSV;"
-                    )
-
-            # add file path to import statement
-            # if import_call_file_prefix is set, replace actual path
-            # with prefix
-            if self.import_call_file_prefix != self.outdir:
-                table_create_command_path = table_create_command_path.replace(
-                    self.outdir,
-                    self.import_call_file_prefix,
-                )
-
-            self.import_call_nodes.add(table_create_command_path)
-
-        return True
-
-    def _write_edge_headers(self):
-        """
-        Writes single CSV file for a graph entity that is represented
-        as an edge as per the definition in the `schema_config.yaml`,
-        containing only the header for this type of edge.
-
-        Returns:
-            bool: The return value. True for success, False otherwise.
-        """
-        # load headers from data parse
-        if not self.edge_property_dict:
-            logger.error(
-                "Header information not found. Was the data parsed first?",
-            )
-            return False
-
-        for label, props in self.edge_property_dict.items():
-            # translate label to PascalCase
-            pascal_label = self.translator.name_sentence_to_pascal(label)
-
-            parts_paths = os.path.join(self.outdir, f"{pascal_label}-part*.csv")
-            parts_paths = glob.glob(parts_paths)
-            parts_paths.sort()
-
-            # adjust label for import to psql
-            pascal_label = self._adjust_pascal_to_psql(pascal_label)
-            table_create_command_path = os.path.join(
-                self.outdir,
-                f"{pascal_label}-create_table.sql",
-            )
-
-            # check for file exists
-            if os.path.exists(table_create_command_path):
-                logger.warning(
-                    f"File {table_create_command_path} already exists. Overwriting.",
-                )
-
-            # concatenate key:value in props
-            columns = []
-            for col_name, col_type in props.items():
-                col_type = self._get_data_type(col_type)
-                col_name = self._adjust_pascal_to_psql(col_name)
-                if col_name == "_ID":
-                    # should ideally never happen
-                    raise ValueError(
-                        "Column name '_ID' is reserved for internal use, "
-                        "denoting the relationship ID. Please choose a "
-                        "different name for your column."
-                    )
-
-                columns.append(f"{col_name} {col_type}")
-
-            # create list of lists and flatten
-            # removes need for empty check of property list
-            out_list = [
-                "_START_ID VARCHAR",
-                "_ID VARCHAR",
-                *columns,
-                "_END_ID VARCHAR",
-                "_TYPE VARCHAR",
-            ]
-
-            with open(table_create_command_path, "w", encoding="utf-8") as f:
-                command = ""
-                if self.wipe:
-                    command += f"DROP TABLE IF EXISTS {pascal_label};\n"
-
-                # table creation requires comma separation
-                command += (
-                    f'CREATE TABLE {pascal_label}({",".join(out_list)});\n'
-                )
-                f.write(command)
-
-                for parts_path in parts_paths:
-                    # if import_call_file_prefix is set, replace actual path
-                    # with prefix
-                    if self.import_call_file_prefix != self.outdir:
-                        parts_path = parts_path.replace(
-                            self.outdir,
-                            self.import_call_file_prefix,
-                        )
-
-                    self._copy_from_csv_commands.add(
-                        f"\\copy {pascal_label} FROM '{parts_path}' DELIMITER E'{self.delim}' CSV;"
-                    )
-
-            # add file path to import statement
-            # if import_call_file_prefix is set, replace actual path
-            # with prefix
-            if self.import_call_file_prefix != self.outdir:
-                table_create_command_path = table_create_command_path.replace(
-                    self.outdir,
-                    self.import_call_file_prefix,
-                )
-
-            self.import_call_edges.add(table_create_command_path)
-
-        return True
-
-    def _construct_import_call(self) -> str:
-        """
-        Function to construct the import call detailing folder and
-        individual node and edge headers and data files, as well as
-        delimiters and database name. Built after all data has been
-        processed to ensure that nodes are called before any edges.
-
-        Returns:
-            str: a bash command for postgresql import
-        """
-        import_call = ""
-
-        # create tables
-        # At this point, csv files of nodes and edges do not require differentiation
-        for import_file_path in [
-            *self.import_call_nodes,
-            *self.import_call_edges,
-        ]:
-            import_call += f'echo "Setup {import_file_path}..."\n'
-            if {self.db_password}:
-                # set password variable inline
-                import_call += f"PGPASSWORD={self.db_password} "
-            import_call += (
-                f"{self.import_call_bin_prefix}psql -f {import_file_path}"
-            )
-            import_call += f" --dbname {self.db_name}"
-            import_call += f" --host {self.db_host}"
-            import_call += f" --port {self.db_port}"
-            import_call += f" --user {self.db_user}"
-            import_call += '\necho "Done!"\n'
-            import_call += "\n"
-
-        # copy data to tables
-        for command in self._copy_from_csv_commands:
-            table_part = command.split(" ")[3]
-            import_call += f'echo "Importing {table_part}..."\n'
-            if {self.db_password}:
-                # set password variable inline
-                import_call += f"PGPASSWORD={self.db_password} "
-            import_call += f'{self.import_call_bin_prefix}psql -c "{command}"'
-            import_call += f" --dbname {self.db_name}"
-            import_call += f" --host {self.db_host}"
-            import_call += f" --port {self.db_port}"
-            import_call += f" --user {self.db_user}"
-            import_call += '\necho "Done!"\n'
-            import_call += "\n"
-
-        return import_call
-
-
-DBMS_TO_CLASS = {
-    "neo": _Neo4jBatchWriter,
-    "neo4j": _Neo4jBatchWriter,
-    "Neo4j": _Neo4jBatchWriter,
-    "postgres": _PostgreSQLBatchWriter,
-    "postgresql": _PostgreSQLBatchWriter,
-    "PostgreSQL": _PostgreSQLBatchWriter,
-    "arango": _ArangoDBBatchWriter,
-    "arangodb": _ArangoDBBatchWriter,
-    "ArangoDB": _ArangoDBBatchWriter,
-}
-
-
-def get_writer(
-    dbms: str,
-    translator: "Translator",
-    deduplicator: "Deduplicator",
-    output_directory: str,
-    strict_mode: bool,
-):
-    """
-    Function to return the writer class based on the selection in the config
-    file.
-
-    Args:
-
-        dbms: the database management system; for options, see DBMS_TO_CLASS.
-
-        translator: the Translator object.
-
-        output_directory: the directory to write the output files to.
-
-        strict_mode: whether to use strict mode.
-
-    Returns:
-
-        instance: an instance of the selected writer class.
-
-    """
-
-    dbms_config = _config(dbms)
-
-    writer = DBMS_TO_CLASS[dbms]
-
-    if not writer:
-        raise ValueError(f"Unknown dbms: {dbms}")
-
-    if writer is not None:
-        return writer(
-            translator=translator,
-            deduplicator=deduplicator,
-            delimiter=dbms_config.get("delimiter"),
-            array_delimiter=dbms_config.get("array_delimiter"),
-            quote=dbms_config.get("quote_character"),
-            output_directory=output_directory,
-            db_name=dbms_config.get("database_name"),
-            import_call_bin_prefix=dbms_config.get("import_call_bin_prefix"),
-            import_call_file_prefix=dbms_config.get("import_call_file_prefix"),
-            wipe=dbms_config.get("wipe"),
-            strict_mode=strict_mode,
-            skip_bad_relationships=dbms_config.get(
-                "skip_bad_relationships"
-            ),  # neo4j
-            skip_duplicate_nodes=dbms_config.get(
-                "skip_duplicate_nodes"
-            ),  # neo4j
-            db_user=dbms_config.get("user"),  # psql
-            db_password=dbms_config.get("password"),  # psql
-            db_port=dbms_config.get("port"),  # psql
-        )