code: def import_lines(
      paths,
      min_partitions=None,
      force_bgz=False,
      force=False,
      file_per_partition=False,
  ) -> Table:
      """Import lines of file(s) as a :class:`.Table` of strings.
  
      Examples
      --------
  
      To import a file as a table of strings:
  
      >>> ht = hl.import_lines('data/matrix2.tsv')
      >>> ht.describe()
      ----------------------------------------
      Global fields:
          None
      ----------------------------------------
      Row fields:
          'file': str
          'text': str
      ----------------------------------------
      Key: []
      ----------------------------------------
  
      Parameters
      ----------
      paths: :class:`str` or :obj:`list` of :obj:`str`
          Files to import.
      min_partitions: :obj:`int` or :obj:`None`
          Minimum number of partitions.
      force_bgz : :obj:`bool`
          If ``True``, load files as blocked gzip files, assuming
          that they were actually compressed using the BGZ codec. This option is
          useful when the file extension is not ``'.bgz'``, but the file is
          blocked gzip, so that the file can be read in parallel and not on a
          single node.
      force : :obj:`bool`
          If ``True``, load gzipped files serially on one core. This should
          be used only when absolutely necessary, as processing time will be
          increased due to lack of parallelism.
      file_per_partition : :obj:`bool`
          If ``True``, each file will be in a seperate partition. Not recommended
          for most uses. Error thrown if ``True`` and `min_partitions` is less than
          the number of files
  
      Returns
      -------
      :class:`.Table`
          Table constructed from imported data.
      """
  
      paths = wrap_to_list(paths)
  
      if file_per_partition and min_partitions is not None:
          if min_partitions > len(paths):
              raise FatalError(
                  f"file_per_partition is True while min partitions is {min_partitions} ,which is greater"
                  f" than the number of files, {len(paths)}"
              )
  
      st_reader = ir.StringTableReader(
          paths, min_partitions, force_bgz, force, file_per_partition
      )
      table_type = hl.ttable(
          global_type=hl.tstruct(),
          row_type=hl.tstruct(file=hl.tstr, text=hl.tstr),
          row_key=[],
      )
      string_table = Table(
          ir.TableRead(st_reader, _assert_type=table_type)
      )
      return string_table
  
imports: import os
  import re
  from collections import defaultdict
  import avro.schema
  from avro.datafile import DataFileReader
  from avro.io import DatumReader
  import hail
  from hail import ir
  from hail.expr import StructExpression, LocusExpression, expr_array, expr_float64, expr_str, expr_numeric, expr_call, expr_bool, expr_int32, to_expr, analyze
  from hail.expr.types import hail_type, tarray, tfloat64, tstr, tint32, tstruct, tcall, tbool, tint64, tfloat32
  from hail.genetics.reference_genome import reference_genome_type
  from hail.ir.utils import parse_type
  from hail.matrixtable import MatrixTable
  from hail.methods.misc import require_biallelic, require_row_key_variant, require_col_key_str
  from hail.table import Table
  from hail.typecheck import typecheck, nullable, oneof, dictof, anytype, sequenceof, enumeration, sized_tupleof, numeric, table_key_type, char
  from hail.utils import new_temp_file
  from hail.utils.deduplicate import deduplicate
  from hail.utils.java import Env, FatalError, jindexed_seq_args, warning
  from hail.utils.java import info
  from hail.utils.misc import wrap_to_list, plural
  from .import_lines_helpers import split_lines, should_remove_line
label_desc: Use image node_id 14 for calling a global function with example usage: import_lines(paths, min_partitions, force_bgz, force, file_per_partition) and returns: string_table