code: def convert_input_data(
      entity_configs: Dict[str, EntitySchema],
      relation_configs: List[RelationSchema],
      entity_path: str,
      edge_paths_out: List[str],
      edge_paths_in: List[Path],
      edgelist_reader: EdgelistReader,
      entity_min_count: int = 1,
      relation_type_min_count: int = 1,
      dynamic_relations: bool = False,
  ) -> None:
      if len(edge_paths_in) != len(edge_paths_out):
          raise ValueError(
              f"The edge paths passed as inputs ({edge_paths_in}) don't match "
              f"the ones specified as outputs ({edge_paths_out})"
          )
  
      entity_storage = ENTITY_STORAGES.make_instance(entity_path)
      relation_type_storage = RELATION_TYPE_STORAGES.make_instance(
          entity_path
      )
      edge_storages = [
          EDGE_STORAGES.make_instance(ep) for ep in edge_paths_out
      ]
  
      some_files_exists = []
      some_files_exists.extend(
          entity_storage.has_count(entity_name, partition)
          for entity_name, entity_config in entity_configs.items()
          for partition in range(entity_config.num_partitions)
      )
      some_files_exists.extend(
          entity_storage.has_names(entity_name, partition)
          for entity_name, entity_config in entity_configs.items()
          for partition in range(entity_config.num_partitions)
      )
      if dynamic_relations:
          some_files_exists.append(relation_type_storage.has_count())
          some_files_exists.append(relation_type_storage.has_names())
      some_files_exists.extend(
          edge_storage.has_edges(UNPARTITIONED, UNPARTITIONED)
          for edge_storage in edge_storages
      )
  
      if all(some_files_exists):
          log(
              "Found some files that indicate that the input data "
              "has already been preprocessed, not doing it again."
          )
          all_paths = ", ".join(
              str(p) for p in [entity_path] + edge_paths_out
          )
          log(f"These files are in: {all_paths}")
          return
  
      relation_types = collect_relation_types(
          relation_configs,
          edge_paths_in,
          dynamic_relations,
          edgelist_reader,
          relation_type_min_count,
      )
  
      entities_by_type = collect_entities_by_type(
          relation_types,
          entity_configs,
          relation_configs,
          edge_paths_in,
          dynamic_relations,
          edgelist_reader,
          entity_min_count,
      )
  
      generate_entity_path_files(
          entity_storage,
          entities_by_type,
          relation_type_storage,
          relation_types,
          dynamic_relations,
      )
  
      for edge_path_in, edge_path_out, edge_storage in zip(
          edge_paths_in, edge_paths_out, edge_storages
      ):
          generate_edge_path_files(
              edge_path_in,
              edge_path_out,
              edge_storage,
              entities_by_type,
              relation_types,
              relation_configs,
              dynamic_relations,
              edgelist_reader,
          )
  
imports: import datetime
  import random
  from abc import ABC, abstractmethod
  from contextlib import ExitStack
  from pathlib import Path
  from typing import Any, Counter, Dict, Iterable, List, Optional, Tuple
  import torch
  from torchbiggraph.config import EntitySchema, RelationSchema
  from torchbiggraph.converters.dictionary import Dictionary
  from torchbiggraph.edgelist import EdgeList
  from torchbiggraph.entitylist import EntityList
  from torchbiggraph.graph_storages import AbstractEdgeAppender, AbstractEdgeStorage, AbstractEntityStorage, AbstractRelationTypeStorage, EDGE_STORAGES, ENTITY_STORAGES, RELATION_TYPE_STORAGES
  from torchbiggraph.types import UNPARTITIONED
label_desc: Use image node_id 7 for calling a global function with example usage: convert_input_data(entity_configs, relation_configs, entity_path, edge_paths_out, edge_paths_in, edgelist_reader, entity_min_count, relation_type_min_count, dynamic_relations) without return types