excel-list-transform 0.5__py3-none-any.whl

excel_list_transform/handle_csv.py

@@ -0,0 +1,73 @@
+#! /usr/local/bin/python3
+"""Handle reading and writing of an excel file."""
+
+# Copyright (c) 2024 Tom Björkholm
+# MIT License
+
+
+from csv import reader, DictReader, writer, DictWriter, Dialect
+from excel_list_transform.handle_empty_column import \
+    handle_empty_column_in_lst, handle_empty_column_in_dict_lst
+from excel_list_transform.num_named_conversion import named_cols_from_num_cols
+from excel_list_transform.commontypes import NumData, NumDataSeq, NameData
+
+
+def read_csv_num(filename: str, dialect: type[Dialect],
+                 max_column_read: int) -> NumData:
+    """Read a csv file in specified dialect (numbered columns)."""
+    res: NumDataSeq = []
+    with open(file=filename, mode="r",
+              encoding='utf_8_sig', newline='') as cfile:
+        creader = reader(cfile, dialect=dialect)
+        for row in creader:
+            res.append(list(row)[:max_column_read])
+    return handle_empty_column_in_lst(res)
+
+
+def read_csv_named_use_num(filename: str, dialect: type[Dialect],
+                           max_column_read: int) -> NameData:
+    """Read a csv file using numbered columns for named columns."""
+    data = read_csv_num(filename=filename, dialect=dialect,
+                        max_column_read=max_column_read)
+    return named_cols_from_num_cols(data=data, filename=filename)
+
+
+def read_csv_named(filename: str, dialect: type[Dialect],
+                   max_column_read: int) -> NameData:
+    """Read a csv file in specified dialect (named columns)."""
+    res = []
+    first_line: bool = True
+    with open(file=filename, mode="r",
+              encoding='utf_8_sig', newline='') as cfile:
+        creader = DictReader(cfile, dialect=dialect)
+        for row in creader:
+            if first_line:
+                if len(row) > max_column_read:
+                    return read_csv_named_use_num(filename=filename,
+                                                  dialect=dialect,
+                                                  max_column_read=  # noqa: E251, E501
+                                                  max_column_read)
+                first_line = False
+            res.append(row)
+    return handle_empty_column_in_dict_lst(res)
+
+
+def write_csv_num(data: NumData,
+                  filename: str, dialect: type[Dialect]) -> None:
+    """Write a csv file in specified dialect."""
+    with open(file=filename, mode="w", encoding='utf8', newline='') as cfile:
+        cwriter = writer(cfile, dialect=dialect)
+        for row in data:
+            cwriter.writerow(row)
+
+
+def write_csv_named(data: NameData,
+                    filename: str, dialect: type[Dialect],
+                    column_order: list[str]) -> None:
+    """Write a csv file in specified dialect."""
+    with open(file=filename, mode="w", encoding='utf8', newline='') as cfile:
+        cwriter = DictWriter(f=cfile, dialect=dialect, fieldnames=column_order,
+                             extrasaction='ignore')
+        cwriter.writeheader()
+        for row in data:
+            cwriter.writerow(row)

excel_list_transform/handle_empty_column.py

@@ -0,0 +1,28 @@
+#! /usr/local/bin/python3
+"""Handle empty column in input."""
+
+# Copyright (c) 2024 Tom Björkholm
+# MIT License
+
+
+from excel_list_transform.commontypes import NameData, NameRow, \
+    NumData, NumRow, NumDataSeq, NameDataMap
+
+
+def handle_empty_column_in_lst(input_data: NumData | NumDataSeq) -> NumData:
+    """Handle empty column in list of lists of input data."""
+    ret: NumData = []
+    for row in input_data:
+        nrow: NumRow = [i if i != '' else None for i in row]
+        ret.append(nrow)
+    return ret
+
+
+def handle_empty_column_in_dict_lst(input_data: NameData | NameDataMap) \
+       -> NameData:
+    """Handle empty column in list of lists of input data."""
+    ret = []
+    for row in input_data:
+        nrow: NameRow = {k: (v if v != '' else None) for (k, v) in row.items()}
+        ret.append(nrow)
+    return ret

excel_list_transform/handle_excel.py

@@ -0,0 +1,161 @@
+#! /usr/bin/python3
+"""Handle reading and writing of an excel file."""
+
+# Copyright (c) 2024 Tom Björkholm
+# MIT License
+
+
+# https://realpython.com/openpyxl-excel-spreadsheets-python/
+
+import sys
+from typing import Optional
+from openpyxl import load_workbook as openpyxl_load_workbook
+from openpyxl import Workbook as openpyxl_wb
+from xlsxwriter import Workbook as xlsxwriter_wb  # type: ignore
+from pylightxl import readxl as pl_readxl  # type: ignore
+from pylightxl import Database as pl_db, writexl as pl_writexl
+from excel_list_transform.commontypes import NameData, NameDataMap, \
+    NumData, NumDataSeq
+from excel_list_transform.config_enums import ExcelLib
+from excel_list_transform.handle_empty_column import handle_empty_column_in_lst
+from excel_list_transform.num_named_conversion import \
+    named_cols_from_num_cols, num_cols_from_named_cols
+
+
+def read_excel_openpyxl(filename: str,
+                        max_column_read: int) \
+                        -> NumData:
+    """Read the excel file using openpyxl."""
+    workbook = openpyxl_load_workbook(filename=filename, read_only=True,
+                                      data_only=True)
+    sheet = workbook.active
+    assert sheet is not None
+    res: NumData = []
+    for row in sheet.iter_rows(values_only=True):
+        res.append(list(row)[:max_column_read])
+    return handle_empty_column_in_lst(res)
+
+
+def read_excel_pyligthxl(filename: str,
+                         max_column_read: int) \
+                         -> NumData:
+    """Read the excel file using pyligthxl."""
+    pyl_db = pl_readxl(fn=filename)
+    sheetnames = pyl_db.ws_names
+    res = []
+    for sheet in sheetnames:
+        for row in pyl_db.ws(ws=sheet).rows:
+            res.append(list(row)[:max_column_read])
+    ret = []
+    for row in res:
+        row = [i if i != '' else None for i in row]
+        ret.append(row)
+    return ret
+
+
+def read_excel_xlsxwriter(filename: str,
+                          max_column_read: int) \
+                          -> NumData:
+    """Flag error and use other read library."""
+    print('xlsxwriter cannot read, using pylightxl.', file=sys.stderr)
+    return read_excel_pyligthxl(filename=filename,
+                                max_column_read=max_column_read)
+
+
+def read_excel_num(filename: str, max_column_read: int,
+                   excel_lib: Optional[ExcelLib] = None) \
+                        -> NumData:
+    """Read the excel file for number referenced columns."""
+    dispatch = {ExcelLib.OPENPYXL: read_excel_openpyxl,
+                ExcelLib.PYLIGHTXL: read_excel_pyligthxl,
+                ExcelLib.XLSXWRITER: read_excel_xlsxwriter}
+    if excel_lib is None:
+        excel_lib = ExcelLib.PYLIGHTXL  # default for now
+    return dispatch[excel_lib](filename=filename,
+                               max_column_read=max_column_read)
+
+
+def read_excel_named(filename: str, max_column_read: int,
+                     excel_lib: Optional[ExcelLib] = None) \
+                        -> NameData:
+    """Read the excel file for name referenced columns."""
+    data = read_excel_num(filename=filename, max_column_read=max_column_read,
+                          excel_lib=excel_lib)
+    return named_cols_from_num_cols(data=data, filename=filename)
+
+
+def write_excel_openpyxl(data: NumData | NumDataSeq,
+                         filename: str) -> None:
+    """Write data as list in excel file using openpyxl."""
+    workbook = openpyxl_wb()
+    sheet = workbook.active
+    assert sheet is not None
+    workbook.encoding = 'utf-8'
+    assert isinstance(data, list)
+    for row in data:
+        assert isinstance(row, (list, tuple))
+        sheet.append(row)
+    workbook.save(filename=filename)
+
+
+def write_excel_pylightxl(data: NumData | NumDataSeq,
+                          filename: str) -> None:
+    """Write data as list in excel file using pylightxl."""
+    pyl_db = pl_db()
+    pyl_db.add_ws(ws="Data")
+    for row_id, row in enumerate(data, start=1):
+        for col_id, elem in enumerate(row, start=1):
+            value = elem if elem is not None else ''
+            pyl_db.ws(ws="Data").update_index(row=row_id, col=col_id,
+                                              val=value)
+    pl_writexl(db=pyl_db, fn=filename)
+
+
+def write_excel_xlsxwriter(data: NumData | NumDataSeq,
+                           filename: str) -> None:
+    """Write data as list in excel file using xlsxwriter."""
+    options = {'in_memory': True,
+               'strings_to_numbers': False,
+               'strings_to_formulaes': False,
+               'strings_to_urls': False,
+               'default_date_format': 'yyyy-mm-dd',
+               'remove_timezone': True}
+    with xlsxwriter_wb(filename=filename, options=options) as workbook:
+        sheet = workbook.add_worksheet()
+        assert isinstance(data, list)
+        for i, row in enumerate(data):
+            assert isinstance(row, (list, tuple))
+            for j, elem in enumerate(row):
+                if elem is not None:
+                    if isinstance(elem, str):
+                        sheet.write_string(row=i, col=j, string=elem)
+                    elif isinstance(elem, int):
+                        sheet.write_number(row=i, col=j, number=elem)
+                    else:
+                        msg = f'Unexpected data type {type(elem).__name__} '
+                        msg += f'for row={i} col={j}. Value {elem}.'
+                        print(msg, file=sys.stderr)
+                        raise RuntimeError(msg)
+
+
+def write_excel_num(data: NumData | NumDataSeq,
+                    filename: str,
+                    excel_lib: Optional[ExcelLib] = None) -> None:
+    """Write data (number referenced columns) as list in excel file."""
+    dispatch = {ExcelLib.OPENPYXL: write_excel_openpyxl,
+                ExcelLib.PYLIGHTXL: write_excel_pylightxl,
+                ExcelLib.XLSXWRITER: write_excel_xlsxwriter}
+    if excel_lib is None:
+        excel_lib = ExcelLib.XLSXWRITER  # default for now
+    dispatch[excel_lib](data=data, filename=filename)
+
+
+def write_excel_named(data: NameDataMap,
+                      filename: str,
+                      column_order: list[str],
+                      excel_lib: Optional[ExcelLib] = None) -> None:
+    """Write data (name referenced columns) as list in excel file."""
+    wdata: NumData = num_cols_from_named_cols(data=data,
+                                              column_order=column_order)
+    write_excel_num(data=wdata, filename=filename,
+                    excel_lib=excel_lib)

excel_list_transform/num_named_conversion.py

@@ -0,0 +1,60 @@
+#! /usr/local/bin/python3
+"""Convert data between numbered columns and named columns."""
+
+# Copyright (c) 2024 Tom Björkholm
+# MIT License
+
+
+import sys
+from excel_list_transform.commontypes import NameData, NumData, \
+    NumDataSeq, NumRow, NameDataMap, \
+    num_row_to_str_list, str_list_to_num_row
+
+
+def named_cols_from_num_cols(data: NumData | NumDataSeq,
+                             filename: str) -> NameData:
+    """Convert data with numbered columns to data with named columns.
+
+    If rows have too few columns, pad as needed with None.
+    """
+    filemsg = f' in file {filename}.'
+    for i, name in enumerate(data[0]):
+        if name is None:
+            print(f'Cannot handle input column {i} without name' + filemsg,
+                  file=sys.stderr)
+            sys.exit(1)
+    names: list[str] = num_row_to_str_list(data[0])
+    num_cols = len(names)
+    ret: NameData = []
+    for row_in in data[1:]:
+        nrow: NumRow = list(row_in)
+        if len(nrow) > num_cols:
+            print('Data row(s) have more columns than title row' + filemsg,
+                  file=sys.stderr)
+            sys.exit(1)
+        while len(nrow) < num_cols:
+            nrow.append(None)
+        ret.append(dict(zip(names, nrow)))
+    return ret
+
+
+def num_cols_from_named_cols(data: NameData | NameDataMap,
+                             column_order: list[str]) -> NumData:
+    """Convert data with named columns to data with numbered columns.
+
+    Silently ignore data with keys not in column_order.
+    If key is missing flag it as error.
+    """
+    ret: NumData = []
+    ret.append(str_list_to_num_row(column_order))
+    for rownum, row in enumerate(data):
+        outrow: NumRow = []
+        for key in column_order:
+            if key in row:
+                outrow.append(row[key])
+            else:
+                msg = f'Data row {rownum} is missing data for column {key}'
+                print(msg, file=sys.stderr)
+                sys.exit(1)
+        ret.append(outrow)
+    return ret

excel_list_transform/rewrite_value.py

@@ -0,0 +1,123 @@
+#! /usr/local/bin/python3
+"""Functions for manipulating and rewriting a value."""
+
+# Copyright (c) 2024 Tom Björkholm
+# MIT License
+
+
+from copy import deepcopy
+import sys
+from typing import Optional, assert_never
+from re import compile as re_compile
+from re import Pattern
+from re import IGNORECASE as re_IGNORECASE
+from re import error as re_error
+from excel_list_transform.commontypes import get_checked_type
+from excel_list_transform.config_enums import RewriteKind, CaseSensitivity
+from excel_list_transform.config_excel_list_transform import \
+    Column, SingleRuleRewrite
+
+
+def strip_value(value: str, chars: str | None,
+                casehandle: CaseSensitivity) -> str:
+    """Strip off characters from beginning/end of value."""
+    if chars is None or chars == '':
+        return value.strip()
+    cha = chars
+    if casehandle == CaseSensitivity.IGNORE_CASE and len(chars) > 0:
+        cha = chars.lower() + chars.upper()
+    return value.strip(cha)
+
+
+def str_replace_value(value: str, fro: str, to: str,
+                      casehandle: CaseSensitivity) -> str:
+    """Replace sub-strings in value."""
+    if casehandle == CaseSensitivity.MATCH_CASE:
+        return value.replace(fro, to)
+    fromstr = deepcopy(fro)
+    pos = -1
+    while True:
+        ret = deepcopy(value)
+        retl = ret.lower()
+        froml = fromstr.lower()
+        pos = retl.find(froml, pos+1)
+        if pos < 0:  # from not found any more
+            break
+        fro_cased = value[pos:pos+len(fro)]
+        value = value.replace(fro_cased, to)
+    return value
+
+
+def remove_from_value(value: str, chars: list[str],
+                      casehandle: CaseSensitivity) -> str:
+    """Remove sub-string from value."""
+    if len(chars) == 0:
+        return value
+    for cha in chars:
+        value = str_replace_value(value=value, fro=cha, to='',
+                                  casehandle=casehandle)
+    return value
+
+
+def regex_replace_value(value: str, fro: str, to: str,
+                        casehandle: CaseSensitivity) -> str:
+    """Replace regexp match in value."""
+    flags = re_IGNORECASE if casehandle == CaseSensitivity.IGNORE_CASE else 0
+    if fro in regex_replace_value_cache:
+        cached: dict[int, Pattern[str]] = regex_replace_value_cache[fro]
+        if flags in cached:
+            re_obj: Pattern[str] = cached[flags]
+            assert re_obj is not None
+            return re_obj.sub(repl=to, string=value)
+    try:
+        re_obj2: Pattern[str] = re_compile(pattern=fro, flags=flags)
+    except re_error as exc:
+        msg = 's7_rewrite_columns: invalid regular expression (regex): '
+        msg += f'"{fro}"\n'
+        msg += str(exc)
+        print(msg, file=sys.stderr)
+        sys.exit(1)
+    assert re_obj2 is not None
+    if fro in regex_replace_value_cache:
+        regex_replace_value_cache[fro][flags] = re_obj2
+    else:
+        regex_replace_value_cache[fro] = {flags: re_obj2}
+    return re_obj2.sub(repl=to, string=value)
+
+
+regex_replace_value_cache: dict[str, dict[int, Pattern[str]]] = {}
+
+
+def rewrite_value(value: Optional[str],
+                  spec: SingleRuleRewrite[Column],
+                  tinfo: Column) -> Optional[str]:
+    """Return a value rewritten according to spec."""
+    if value is None:
+        return None
+    assert value is not None
+    assert tinfo is not None  # tinfo needed for mypy, avoid pylint unused
+    ret: str = deepcopy(value)
+    kind: RewriteKind = get_checked_type(spec['kind'], RewriteKind)
+    casehandle: CaseSensitivity = get_checked_type(spec['case'],
+                                                   CaseSensitivity)
+    if kind == RewriteKind.STRIP:
+        chars1 = spec['chars']
+        if chars1 is not None:
+            assert isinstance(chars1, str)
+        return strip_value(value=ret, chars=chars1,
+                           casehandle=casehandle)
+    if kind == RewriteKind.REMOVECHARS:
+        chars: list[str] = get_checked_type(spec['chars'], list)
+        return remove_from_value(value=ret, chars=chars,
+                                 casehandle=casehandle)
+    fro: str = get_checked_type(spec['from'], str)
+    to: str = get_checked_type(spec['to'], str)
+    if kind == RewriteKind.STR_SUBSTITUTE:
+        return str_replace_value(value=ret, fro=fro, to=to,
+                                 casehandle=casehandle)
+    if kind == RewriteKind.REGEX_SUBSTITUTE:
+        return regex_replace_value(value=ret, fro=fro, to=to,
+                                   casehandle=casehandle)
+    assert_never(f'unexpected value kind={kind.name} in ' +
+                 'rewrite_value')  # pylint: disable=unreachable,line-too-long  # pragma: no cover # noqa: E501
+    assert False  # pylint: disable=unreachable,line-too-long  # pragma: no cover # noqa: E501

excel_list_transform/str_to_enum.py

@@ -0,0 +1,39 @@
+#! /usr/local/bin/python3
+"""Functions to fuzzy parse string into enum."""
+
+# Copyright (c) 2024 Tom Björkholm
+# MIT License
+
+
+from enum import Enum
+from typing import TypeVar, Optional
+
+SomeEnum = TypeVar('SomeEnum', bound=Enum)
+
+
+def string_to_enum_best_match(inp: str, num_type: type[SomeEnum]) -> SomeEnum:
+    """Find the enum that is the best match for string.
+
+    Parameters:
+    inp: the string that should match an enum value
+    num_type: the enumeration class to find enum values in
+    """
+    assert isinstance(inp, str), 'string_to_enum_best_match called ' + \
+        f'with {type(inp).__name__} not str as expected.'
+    for variant in (inp, inp.capitalize(), inp.lower(), inp.upper()):
+        try:
+            return num_type[variant]
+        except KeyError:
+            pass
+    num_match: int = 0
+    match: Optional[SomeEnum] = None
+    for i in num_type:
+        if i.name.upper()[0:len(inp)] == inp.upper():
+            num_match += 1
+            match = i
+    if num_match == 1 and match is not None:
+        assert match is not None
+        assert isinstance(match, num_type)
+        return match
+    errstr = inp + ' is not one of: ' + ', '.join([e.name for e in num_type])
+    raise KeyError(errstr)

excel_list_transform/transform_cmd.py

@@ -0,0 +1,146 @@
+#! /usr/local/bin/python3
+"""Command to transform list in excel or CSV file."""
+
+# Copyright (c) 2024 Tom Björkholm
+# MIT License
+
+
+from copy import deepcopy
+from sys import argv as sys_argv
+from typing import Optional, TypeAlias
+import argparse
+from excel_list_transform.transform_func import transform_named_files
+from excel_list_transform.generate_cfg import generate_examplecfg
+from excel_list_transform.generate_cfg import get_example_names
+from excel_list_transform.config_enums import ColumnRef
+from excel_list_transform.str_to_enum import string_to_enum_best_match
+
+
+def gen_cfg_cmd(args: argparse.Namespace) -> int:
+    """Generate example cfg file."""
+    outfilename: str = args.output[0]
+    cfgtype: str = args.kind[0]
+    colref: ColumnRef = string_to_enum_best_match(args.reference[0],
+                                                  ColumnRef)
+    return generate_examplecfg(filename=outfilename,
+                               cfgtype=cfgtype, colref=colref)
+
+
+def rfmt_cmd(args: argparse.Namespace) -> int:
+    """Generate example cfg file."""
+    outfilename = args.output[0]
+    infilename = args.input[0]
+    cfgfilename = args.cfg[0]
+    return transform_named_files(infilename=infilename,
+                                 outfilename=outfilename,
+                                 cfgfilename=cfgfilename)
+
+
+USAGE_ORDER = '''
+The normal way to use this command is:
+(1) Using the "example" sub-command a few example configuration (.cfg) files
+with description (.txt) files are generated.
+(2) Read the example configuration (.cfg) files and the accompanying
+description (.txt) files.
+(3) Find an example that is close to what you want to achieve.
+(4) Modify that configuration file to achieve what you want to achieve.
+(5) Use the "transform" sub-command to read your data and output it
+transformed or reorganized according to your modified configuration
+file.
+(6) Read the produced output. If necessary go back to step 4 and adjust
+how the data is transformed.
+'''
+
+TXT_DESCRIPTION = '''
+When generating an example configuration file a text file describing
+the configuration file syntax is also generated, with the same name
+as the configuration file but with extension .txt instead of .cfg.
+'''
+
+GENERAL_DESCRIPTION = '''
+Transform or reorganize list in excel or CSV file. How data is transformed
+is described in a configuration file. Name of input file,
+output file and configuration file is given as command line
+arguments.
+The command can also generate a few example configuration files.
+When generating an example configuration file the output file name
+switch gives the name of the generated configuration file.
+'''
+
+SEE_MAIN_HELP = '''
+See also help text for main command without sub-commands.
+'''
+
+SubParseAct: TypeAlias = 'argparse._SubParsersAction[argparse.ArgumentParser]'
+
+
+def gen_cfg_args(subparsers: SubParseAct) -> None:
+    """Add arguments for generate example config sub-command."""
+    cfg_help = 'Generate example configuration file (example .cfg file). '
+    cfg_help += 'Arguments select the kind of configuration file that '
+    cfg_help += 'is generated.'
+    cfg_parser = subparsers.add_parser('example', help=cfg_help,
+                                       epilog=USAGE_ORDER,
+                                       description=cfg_help +
+                                       TXT_DESCRIPTION + SEE_MAIN_HELP)
+    cfg_parser.set_defaults(func=gen_cfg_cmd)
+    examplekinds = get_example_names()
+    kind_help = 'Kind of example to generate configuration file for.'
+    kind_help += 'Possible kinds are (' + ', '.join(examplekinds) + ').'
+    cfg_parser.add_argument('-k', '--kind', nargs=1, required=True,
+                            help=kind_help, choices=examplekinds)
+    reftypes = [e.name.lower() for e in ColumnRef]
+    ref_help = 'How does configuration file reference to columns '
+    ref_help += 'in the data. By column number of by column name. '
+    ref_help += 'Possible values are (' + ', '.join(reftypes) + '). '
+    ref_help += 'Normally "by_name" column references are easier to get right.'
+    cfg_parser.add_argument('-r', '--reference', nargs=1, required=True,
+                            help=ref_help, choices=reftypes)
+    cfg_output_help = 'Name of configuration (output) file to create.'
+    cfg_parser.add_argument('-o', '--output', nargs=1,
+                            help=cfg_output_help, required=True)
+
+
+def rfmt_args(subparsers: SubParseAct) -> None:
+    """Add arguments for transform sub-command."""
+    rfmt_help = 'Transform list in excel or CSV file. How data is transformed '
+    rfmt_help += 'is described in a configuration file. Name of input file, '
+    rfmt_help += 'output file and configuration file is given as command '
+    rfmt_help += 'line arguments.'
+    rfmt_parser = subparsers.add_parser('transform', help=rfmt_help,
+                                        epilog=USAGE_ORDER,
+                                        description=rfmt_help + SEE_MAIN_HELP)
+    rfmt_parser.set_defaults(func=rfmt_cmd)
+    rfmt_parser.add_argument('-c', '--cfg', nargs=1, required=True,
+                             help='Configuation file name to use.')
+    rfmt_parser.add_argument('-i', '--input', nargs=1,
+                             help='Name of input file.', required=True)
+    rfmt_parser.add_argument('-o', '--output', nargs=1,
+                             help='Name of output file to create.',
+                             required=True)
+
+
+def transform_cmd(arguments: Optional[list[str]] = None) -> None:
+    """Command to transform list in excel or CSV file."""
+    epimain = 'More detailed help is available for each sub-command.'
+    if arguments is None:  # pragma: no cover
+        arguments = sys_argv
+    fixed_args = deepcopy(arguments)
+    if len(fixed_args) > 2 and 'python' in fixed_args[0]:
+        del fixed_args[0]
+    if len(fixed_args) > 2 and '-m' == fixed_args[0]:
+        del fixed_args[0]
+    while len(fixed_args) > 1 and fixed_args[0][-3:] == '.py':
+        del fixed_args[0]
+    desc = GENERAL_DESCRIPTION + \
+        USAGE_ORDER
+    parser = argparse.ArgumentParser(description=desc, epilog=epimain)
+    subparsers = parser.add_subparsers(dest='subparser_name', required=True)
+    gen_cfg_args(subparsers)
+    rfmt_args(subparsers)
+    args = parser.parse_args(args=fixed_args)
+    _ = args.func(args)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    transform_cmd()

excel_list_transform/transform_func.py

@@ -0,0 +1,50 @@
+#! /usr/local/bin/python3
+"""Function for doing transform of lists excel files."""
+
+# Copyright (c) 2024 Tom Björkholm
+# MIT License
+
+
+from typing import Callable, Mapping
+from excel_list_transform.config_enums import ColumnRef, FileType
+from excel_list_transform.file_extension import fix_file_extension
+from excel_list_transform.config_factory import config_factory_from_json
+from excel_list_transform.config import Config
+from excel_list_transform.transform_func_num import transform_named_files_num
+from excel_list_transform.transform_func_named import \
+    transform_named_files_name
+from excel_list_transform.file_must_exist import file_must_exist
+
+
+def transform_named_files(infilename: str, outfilename: str,
+                          cfgfilename: str) -> int:
+    """Transform list in the named excel file to named file."""
+    fixed_cfgfilename = fix_file_extension(filename=cfgfilename,
+                                           ext_to_add='.cfg')
+    file_must_exist(fixed_cfgfilename)
+    cfg = config_factory_from_json(from_json_filename=cfgfilename)
+    fixed_infilename = None
+    if cfg.in_type == FileType.CSV:
+        fixed_infilename = fix_file_extension(filename=infilename,
+                                              ext_to_add='.csv',
+                                              for_reading=True)
+        file_must_exist(fixed_infilename)
+    else:
+        fixed_infilename = fix_file_extension(filename=infilename,
+                                              ext_to_add='.xlsx',
+                                              for_reading=True)
+        file_must_exist(fixed_infilename)
+    fixed_outfilename = None
+    if cfg.out_type == FileType.CSV:
+        fixed_outfilename = fix_file_extension(filename=outfilename,
+                                               ext_to_add='.csv')
+    else:
+        fixed_outfilename = fix_file_extension(filename=outfilename,
+                                               ext_to_add='.xlsx')
+    dispatch: Mapping[ColumnRef,
+                      Callable[[str, str, Config], None]] = \
+        {ColumnRef.BY_NUMBER: transform_named_files_num,
+         ColumnRef.BY_NAME: transform_named_files_name}
+    dispatch[cfg.column_ref](fixed_infilename, fixed_outfilename,
+                             cfg)
+    return 0