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

excel_list_transform/transform_func_common.py

@@ -0,0 +1,249 @@
+#! /usr/local/bin/python3
+"""Functions for doing transform of lists excel files."""
+
+# Copyright (c) 2024 Tom Björkholm
+# MIT License
+
+
+import sys
+from copy import deepcopy
+from excel_list_transform.config_enums import SplitWhere
+from excel_list_transform.config_excel_list_transform import Column, \
+    Rule, RuleMerge, RuleRewrite, RuleSplit, SingleRuleSplit, \
+    ConfigExcelListTransform
+from excel_list_transform.rewrite_value import rewrite_value
+from excel_list_transform.commontypes import  \
+    NumRow, NameRow, NumRowSeq, NameRowMap, Data, Value
+# NumData, NumDataSeq, NameData, NameDataMap,
+
+
+def col_must_exist_num(col: int, row: NumRowSeq, param: str) -> None:
+    """Stop with error report if column does not exist (num case)."""
+    if col < 0 or col >= len(row):
+        msg = f'{param}: column index {col} out of range [0, {len(row)-1}].'
+        print(msg, file=sys.stderr)
+        sys.exit(1)
+
+
+def col_must_exist_name(col: str, row: NameRowMap, param: str) -> None:
+    """Stop with error report if column does not exist (name case)."""
+    if col not in row:
+        msg: str = f'{param}: no column named "{col}" in data row.'
+        print(msg, file=sys.stderr)
+        sys.exit(1)
+
+
+def col_must_exist(col: Column, row: NumRowSeq | NameRowMap,
+                   param: str) -> None:
+    """Stop with error report if column does not exist."""
+    if isinstance(col, str):
+        assert isinstance(col, str)
+        assert isinstance(row, dict)
+        col_must_exist_name(col=col, row=row, param=param)
+    else:
+        assert isinstance(col, int)
+        assert isinstance(row, list)
+        col_must_exist_num(col=col, row=row, param=param)
+
+
+def cols_must_exist_lst(cols: list[Column], row: NumRowSeq | NameRowMap,
+                        param: str, tinfo: Column) -> None:
+    """Stop with error report all if columns does not exist."""
+    for col in cols:
+        assert isinstance(col, type(tinfo))
+        col_must_exist(col=col, row=row, param=param)
+
+
+def cols_must_exist_dict(rule:  Rule[Column] | RuleSplit[Column] |
+                         RuleRewrite[Column],
+                         row: NumRowSeq | NameRowMap,
+                         param: str, tinfo: Column) -> None:
+    """Stop with error report if columns does not exist."""
+    cols = ConfigExcelListTransform.get_cols_single(rule=rule, tinfo=tinfo)
+    cols_must_exist_lst(cols=cols, row=row, param=param, tinfo=tinfo)
+
+
+def cols_must_exist_dictlst(rule: RuleMerge[Column],
+                            row: NumRowSeq | NameRowMap,
+                            param: str, tinfo: Column) -> None:
+    """Stop with error report if columns does not exist."""
+    cols = ConfigExcelListTransform.get_cols_multi(rule=rule, tinfo=tinfo)
+    cols_must_exist_lst(cols=cols, row=row, param=param, tinfo=tinfo)
+
+
+def store_col_split_num(row: NumRow, colref: int, val: list[str],
+                        singlerule: SingleRuleSplit[int]) -> None:
+    """Store result of column split for number refs."""
+    if len(val) == 0:
+        for _ in range(2):
+            row.insert(colref, None)
+        return
+    if len(val) == 1:
+        if singlerule['store_single'] != SplitWhere.RIGHTMOST:
+            row.insert(colref, None)
+            row.insert(colref, val[0])
+        else:
+            row.insert(colref, val[0])
+            row.insert(colref, None)
+        return
+    for j in reversed(val):
+        row.insert(colref, j)
+
+
+def store_col_split_name(row: NameRow, colref: str, val: list[str],
+                         singlerule: SingleRuleSplit[str]) -> None:
+    """Store result of column split for number refs."""
+    rightname = singlerule['right_name']
+    assert isinstance(rightname, str)
+    row[rightname] = None
+    if len(val) == 0:
+        row[colref] = None
+    elif len(val) == 1:
+        row[colref] = val[0]
+    else:
+        row[colref] = val[0]
+        row[rightname] = val[1]
+
+
+def pop_from_row(row: NumRow | NameRow, colref: Column) -> Value:
+    """Keep mypy happy with row.pop."""
+    if isinstance(colref, int):
+        assert isinstance(colref, int)
+        assert isinstance(row, list)
+        return row.pop(colref)
+    assert isinstance(colref, str)
+    assert isinstance(row, dict)
+    return row.pop(colref)
+
+
+def split_columns(indata: Data, cfg: ConfigExcelListTransform[Column],
+                  tinfo: Column) -> Data:
+    """Split columns in the in indata."""
+    if len(cfg.s1_split_columns) == 0:
+        return indata
+    ret = deepcopy(indata)
+    for row in ret:
+        cols_must_exist_dict(rule=cfg.s1_split_columns, row=row,
+                             param='s1_split_columns', tinfo=tinfo)
+        for i in reversed(cfg.s1_split_columns):
+            colref = i['column']
+            assert isinstance(colref, type(tinfo))
+            sep = i['separator']
+            assert isinstance(sep, str)
+            inval = pop_from_row(row=row, colref=colref)
+            val: list[str] = []
+            if inval is not None:
+                if not isinstance(inval, str):
+                    msg = 's1_split_columns: '
+                    msg += 'Can only split columns with string values.\n'
+                    msg += f'Column "{colref}" has value of '
+                    msg += f'type {type(inval).__name__}'
+                    print(msg, file=sys.stderr)
+                    sys.exit(1)
+                assert isinstance(inval, str)
+                if i['where'] == SplitWhere.RIGHTMOST:
+                    val = inval.rsplit(sep=sep, maxsplit=1)
+                else:
+                    val = inval.split(sep=sep, maxsplit=1)
+            if isinstance(tinfo, str):
+                assert isinstance(row, dict)
+                assert isinstance(colref, str)
+                store_col_split_name(row=row, colref=colref, val=val,
+                                     singlerule=i)
+            else:
+                assert isinstance(row, list)
+                assert isinstance(colref, int)
+                store_col_split_num(row=row, colref=colref, val=val,
+                                    singlerule=i)
+    return ret
+
+
+def insert_into_row(row: NumRow | NameRow, colref: Column, val: Value) -> None:
+    """Keep mypy happy insert into row."""
+    if isinstance(colref, int):
+        assert isinstance(colref, int)
+        assert isinstance(row, list)
+        row.insert(colref, val)
+        return
+    assert isinstance(colref, str)
+    assert isinstance(row, dict)
+    row[colref] = val
+
+
+def merge_columns(indata: Data, cfg: ConfigExcelListTransform[Column],
+                  tinfo: Column) -> Data:
+    """Merge columns in the list in indata with column number refs."""
+    if len(cfg.s3_merge_columns) == 0:
+        return indata
+    ret = deepcopy(indata)
+    for row in ret:
+        cols_must_exist_dictlst(rule=cfg.s3_merge_columns, row=row,
+                                param='s3_merge_columns', tinfo=tinfo)
+        for i in reversed(cfg.s3_merge_columns):
+            colspec = i['columns']
+            assert isinstance(colspec, list)
+            if len(colspec) < 2:
+                continue
+            colref = colspec[0]
+            assert isinstance(colref, type(tinfo))
+            vals: list[str] = []
+            for j in reversed(colspec):
+                assert isinstance(j, type(tinfo))
+                popval = pop_from_row(row=row, colref=j)
+                if popval is not None:
+                    vals.insert(0, str(popval))
+            if len(vals) > 0:
+                sep = i['separator']
+                assert isinstance(sep, str)
+                insert_into_row(row=row, colref=colref,
+                                val=sep.join(vals))
+            else:
+                insert_into_row(row=row, colref=colref, val=None)
+    return ret
+
+
+def row_element(row: NumRow | NameRow, idx: Column, tinfo: Column) -> Value:
+    """Keep mypy happy with accessing element in dict or list."""
+    assert isinstance(idx, type(tinfo))
+    if isinstance(idx, int):
+        assert isinstance(idx, int)
+        assert isinstance(row, list)
+        return row[idx]
+    assert isinstance(idx, str)
+    assert isinstance(row, dict)
+    return row[idx]
+
+
+def set_row_element(row: NumRow | NameRow, idx: Column, tinfo: Column,
+                    val: Value) -> None:
+    """Keep mypy happy with accessing element in dict or list."""
+    assert isinstance(idx, type(tinfo))
+    if isinstance(idx, int):
+        assert isinstance(idx, int)
+        assert isinstance(row, list)
+        row[idx] = val
+        return
+    assert isinstance(idx, str)
+    assert isinstance(row, dict)
+    row[idx] = val
+
+
+def rewrite_columns(indata: Data, cfg: ConfigExcelListTransform[Column],
+                    tinfo: Column) -> Data:
+    """Rewrite columns in the list in indata with column number refs."""
+    if len(cfg.s7_rewrite_columns) == 0:
+        return indata
+    ret = deepcopy(indata)
+    for row in ret:
+        cols_must_exist_dict(rule=cfg.s7_rewrite_columns, row=row,
+                             param='s7_rewrite_columns', tinfo=tinfo)
+        for i in cfg.s7_rewrite_columns:
+            colref = i['column']
+            assert isinstance(colref, type(tinfo))
+            oldvalue = row_element(row=row, idx=colref, tinfo=tinfo)
+            if oldvalue is None:
+                continue
+            assert oldvalue is not None
+            newvalue = rewrite_value(value=str(oldvalue), spec=i, tinfo=tinfo)
+            set_row_element(row=row, idx=colref, tinfo=tinfo, val=newvalue)
+    return ret

excel_list_transform/transform_func_named.py

@@ -0,0 +1,136 @@
+#! /usr/local/bin/python3
+"""Functions for doing transform of lists excel files."""
+
+# Copyright (c) 2024 Tom Björkholm
+# MIT License
+
+
+import sys
+from copy import deepcopy
+from excel_list_transform.handle_csv import read_csv_named, write_csv_named
+from excel_list_transform.handle_excel import \
+    read_excel_named, write_excel_named
+from excel_list_transform.config_enums import \
+    FileType
+from excel_list_transform.config import Config
+from excel_list_transform.config_xls_list_refmt_name import \
+    ConfigXlsListRefmtName
+from excel_list_transform.check_indata_common import check_indata_common
+from excel_list_transform.commontypes import NameData, get_checked_type
+from excel_list_transform.transform_func_common import \
+    cols_must_exist_dict, split_columns, merge_columns, rewrite_columns
+
+
+def rename_columns_name(indata: NameData,
+                        cfg: ConfigXlsListRefmtName) -> NameData:
+    """Rename columns in the list in indata with column name refs."""
+    if len(cfg.s5_rename_columns) == 0:
+        return indata
+    ret = deepcopy(indata)
+    for row in ret:
+        cols_must_exist_dict(rule=cfg.s5_rename_columns, row=row,
+                             param='s5_rename_columns', tinfo='a')
+        for i in cfg.s5_rename_columns:
+            from_name: str = get_checked_type(value=i['column'], istype=str)
+            to_name: str = get_checked_type(value=i['name'], istype=str)
+            val = row.pop(from_name)
+            row[to_name] = val
+    return ret
+
+
+def insert_columns_name(indata: NameData,
+                        cfg: ConfigXlsListRefmtName) -> NameData:
+    """Insert columns in the list in indata with column name refs."""
+    if len(cfg.s6_insert_columns) == 0:
+        return indata
+    ret = deepcopy(indata)
+    for row in ret:
+        for i in cfg.s6_insert_columns:
+            col: str = get_checked_type(value=i['column'], istype=str)
+            val = i['value']
+            if col in row:
+                msg = f's6_insert_columns: column "{col}" '
+                msg += 'already exists.'
+                print(msg, file=sys.stderr)
+                sys.exit(1)
+            row[col] = val
+    return ret
+
+
+def fix_indata_empty_rows_name(indata: NameData) -> None:  # pylint: disable=duplicate-code # noqa: E501
+    """Check rows and remove empty rows with column name refs."""
+    for i, row in reversed(list(enumerate(indata))):
+        if not isinstance(row, dict):
+            msg = 'Internal error. Expected dict of columns but got '
+            msg += type(row).__name__  # pylint: disable=duplicate-code # noqa: E501
+            print(msg, file=sys.stderr)
+            raise TypeError(msg)
+        if len(row) == 0:
+            del indata[i]
+            continue
+        for val in row.values():
+            if val is not None and not isinstance(val, str):
+                return  # last row not empty
+            if val is not None and isinstance(val, str):
+                if len(val) > 0:
+                    return  # last rown not empty
+        # last row is empty, remove it
+        keys = deepcopy(list(row.keys()))
+        for key in keys:
+            del row[key]
+        del indata[i]
+    return
+
+
+def check_indata_name(indata: NameData) -> None:
+    """Check that the indata is well formed with column name refs."""
+    check_indata_common(indata=indata,
+                        fix_indata_empty_rows=fix_indata_empty_rows_name)
+    cols = None
+    for row in indata:
+        rowcols = sorted(row.keys())
+        if cols is None:
+            cols = rowcols
+        else:
+            if cols != rowcols:
+                msg = 'Columns names different between lines. '
+                msg += f'Found {cols} and {rowcols}. Aborting.'
+                print(msg, file=sys.stderr)
+                raise RuntimeError(msg)
+
+
+def transform_data_name(indata: NameData,
+                        cfg: ConfigXlsListRefmtName) -> NameData:
+    """Transform list in the data with column number refs."""
+    check_indata_name(indata=indata)
+    ret = split_columns(indata=indata, cfg=cfg, tinfo='a')
+    ret = merge_columns(indata=ret, cfg=cfg, tinfo='a')
+    ret = rename_columns_name(indata=ret, cfg=cfg)
+    ret = insert_columns_name(indata=ret, cfg=cfg)
+    ret = rewrite_columns(indata=ret, cfg=cfg, tinfo='a')
+    return ret
+
+
+def transform_named_files_name(infilename: str, outfilename: str,
+                               cfg: Config) -> None:
+    """Transform list in the named excel file to named file."""
+    cfgn: ConfigXlsListRefmtName = \
+        get_checked_type(value=cfg, istype=ConfigXlsListRefmtName)
+    indata = None
+    if cfgn.in_type == FileType.CSV:
+        indata = read_csv_named(infilename, cfgn.get_in_csv_dialect(),
+                                max_column_read=cfgn.max_column_read)
+    else:
+        indata = read_excel_named(infilename,
+                                  max_column_read=cfgn.max_column_read,
+                                  excel_lib=cfgn.in_excel_library)
+    outdata = transform_data_name(indata=indata, cfg=cfgn)
+    if cfgn.out_type == FileType.CSV:
+        write_csv_named(data=outdata, filename=outfilename,
+                        dialect=cfgn.get_out_csv_dialect(),
+                        column_order=cfgn.s8_column_order)
+    else:
+        write_excel_named(data=outdata, filename=outfilename,
+                          column_order=cfgn.s8_column_order,
+                          excel_lib=cfgn.out_excel_library)
+    print(f'Wrote {outfilename}')

excel_list_transform/transform_func_num.py

@@ -0,0 +1,157 @@
+#! /usr/local/bin/python3
+"""Functions for doing transform of lists excel files."""
+
+# Copyright (c) 2024 Tom Björkholm
+# MIT License
+
+
+import sys
+from copy import deepcopy
+from excel_list_transform.handle_csv import read_csv_num, write_csv_num
+from excel_list_transform.handle_excel import read_excel_num, write_excel_num
+from excel_list_transform.config_enums import FileType
+from excel_list_transform.commontypes import NumData, get_checked_type
+from excel_list_transform.config import Config
+from excel_list_transform.config_xls_list_refmt_num import \
+    ConfigXlsListRefmtNum
+from excel_list_transform.check_indata_common import check_indata_common
+from excel_list_transform.transform_func_common import \
+    cols_must_exist_dict, cols_must_exist_lst, split_columns, merge_columns, \
+    rewrite_columns
+
+
+def remove_columns_num(indata: NumData,
+                       cfg: ConfigXlsListRefmtNum) -> NumData:
+    """Remove columns in the list in indata with column number refs."""
+    if len(cfg.s2_remove_columns) == 0:
+        return indata
+    ret = deepcopy(indata)
+    for row in ret:
+        rowlen = len(row)
+        cols_must_exist_lst(cols=cfg.s2_remove_columns, row=row,
+                            param='s2_remove_columns', tinfo=2)
+        for i in reversed(cfg.s2_remove_columns):
+            if 0 <= i < rowlen:
+                row.pop(i)
+    return ret
+
+
+def place_columns_first(indata: NumData,
+                        cfg: ConfigXlsListRefmtNum) -> NumData:
+    """Place columns first in the list in indata."""
+    if len(cfg.s4_place_columns_first) == 0:
+        return indata
+    ret = deepcopy(indata)
+    for row_i, row in enumerate(ret):
+        rowlen = len(row)
+        cols_must_exist_lst(cols=cfg.s4_place_columns_first, row=row,
+                            param='s4_place_columns_first', tinfo=2)
+        drow = dict(enumerate(row))
+        order = deepcopy(cfg.s4_place_columns_first)
+        for i in range(rowlen):
+            if i not in order:
+                order.append(i)
+        nrow = []
+        for i in order:
+            nrow.append(drow[i])
+        ret[row_i] = nrow
+    return ret
+
+
+def rename_columns_num(indata: NumData,
+                       cfg: ConfigXlsListRefmtNum) -> NumData:
+    """Rename columns in the list in indata with column number refs."""
+    assert isinstance(cfg.s5_rename_columns, list)
+    if len(cfg.s5_rename_columns) == 0:
+        return indata
+    ret = deepcopy(indata)
+    cols_must_exist_dict(rule=cfg.s5_rename_columns, row=ret[0],
+                         param='s5_rename_columns', tinfo=2)
+    for i in cfg.s5_rename_columns:
+        colref: int = get_checked_type(i['column'], int)
+        assert isinstance(colref, int)
+        ret[0][colref] = get_checked_type(i['name'], str)
+    return ret
+
+
+def insert_columns_num(indata: NumData,
+                       cfg: ConfigXlsListRefmtNum) -> NumData:
+    """Insert columns in the list in indata with column number refs."""
+    assert isinstance(cfg.s6_insert_columns, list)
+    if len(cfg.s6_insert_columns) == 0:
+        return indata
+    ret = deepcopy(indata)
+    for row_i, row in enumerate(ret):
+        for i in cfg.s6_insert_columns:
+            colref: int = get_checked_type(value=i['column'], istype=int)
+            if not 0 <= colref <= len(row):
+                msg = f's6_insert_columns: column index {colref} out of '
+                msg += f'range [0, {len(row)}].'
+                print(msg, file=sys.stderr)
+                sys.exit(1)
+            name: str = get_checked_type(i['name'], str)
+            to_insert = name if row_i == 0 else i['value']
+            if colref == len(row):
+                row.append(to_insert)
+            else:
+                row.insert(colref, to_insert)
+    return ret
+
+
+def fix_indata_empty_rows_num(indata: NumData) -> None:  # pylint: disable=duplicate-code # noqa: E501
+    """Check rows and remove empty rows with column number refs."""
+    for i, row in reversed(list(enumerate(indata))):
+        assert isinstance(row, list), 'Internal error. Expected list of ' + \
+            f'columns but got {type(row).__name__}'  # pylint: disable=duplicate-code # noqa: E501
+        if len(row) == 0:
+            del indata[i]
+        elif len(row) == 1:
+            if row[0] is None:
+                del indata[i][0]
+                del indata[i]
+            elif isinstance(row[0], str) and len(row[0]) == 0:
+                del indata[i][0]
+                del indata[i]
+
+
+def check_indata_num(indata: NumData) -> None:
+    """Check that the indata is well formed with column number refs."""
+    check_indata_common(indata=indata,
+                        fix_indata_empty_rows=fix_indata_empty_rows_num)
+
+
+def transform_data_num(indata: NumData,
+                       cfg: ConfigXlsListRefmtNum) -> NumData:
+    """Transform list in the data with column number refs."""
+    check_indata_num(indata=indata)
+    ret = split_columns(indata=indata, cfg=cfg, tinfo=2)
+    ret = remove_columns_num(indata=ret, cfg=cfg)
+    ret = merge_columns(indata=ret, cfg=cfg, tinfo=2)
+    ret = place_columns_first(indata=ret, cfg=cfg)
+    ret = rename_columns_num(indata=ret, cfg=cfg)
+    ret = insert_columns_num(indata=ret, cfg=cfg)
+    ret = rewrite_columns(indata=ret, cfg=cfg, tinfo=2)
+    return ret
+
+
+def transform_named_files_num(infilename: str, outfilename: str,
+                              cfg: Config) -> None:
+    """Transform list in the named excel file to named file."""
+    cfgn: ConfigXlsListRefmtNum = \
+        get_checked_type(value=cfg, istype=ConfigXlsListRefmtNum)
+    indata = None
+    if cfgn.in_type == FileType.CSV:
+        indata = read_csv_num(infilename, cfgn.get_in_csv_dialect(),
+                              max_column_read=cfgn.max_column_read)
+    else:
+        indata = read_excel_num(infilename,
+                                max_column_read=cfgn.max_column_read,
+                                excel_lib=cfgn.in_excel_library)
+    outdata = transform_data_num(indata=indata, cfg=cfgn)
+    if cfgn.out_type == FileType.CSV:
+        write_csv_num(data=outdata, filename=outfilename,
+                      dialect=cfgn.get_out_csv_dialect())
+    else:
+        write_excel_num(data=outdata, filename=outfilename,
+                        excel_lib=cfgn.out_excel_library)
+    print(f'Wrote {outfilename}')

excel_list_transform-0.5.dist-info/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Tom Björkholm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

excel_list_transform-0.5.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.1
+Name: excel-list-transform
+Version: 0.5
+Summary: Transform a list in excel or CSV
+Author: Tom Björkholm
+Author-email: Tom Björkholm <klausuler_linnet0q@icloud.com>
+Project-URL: Source code, https://bitbucket.org/tom-bjorkholm/excel-list-transform
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10.5
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: openpyxl >=3.1.5
+Requires-Dist: types-openpyxl >=3.1.5.20240822
+Requires-Dist: pylightxl >=1.61
+Requires-Dist: XlsxWriter >=3.2.0
+Requires-Dist: pip >=23.2
+Requires-Dist: Pillow >=10.0.1
+Requires-Dist: setuptools >=74.0.0
+Requires-Dist: build >=1.2.1
+Requires-Dist: wheel >=0.44.0
+
+# excel-list-transform
+
+## Background
+
+This python application was born out of an experience at sail racing events. At the start of the events we received an excel list with participants (from a registration web) to enter into the scoring software and into tool for online notice board. The information was present in the excel file, but the columns were all wrong. To avoid the stressful manual rework of the information in the excel list this application was created.
+
+## What it does
+
+This small python application:
+ * reads data (that is a list with columns) from an excel file or from a comma separate values (CSV) file.
+ * splits columns in the list (like creating "first name" and "last name" columns from "name" column)
+ * merges columns in the list (like creating "name" column from "first name" and "last name" columns)
+ * removes columns in the list
+ * reorders columns in the list
+ * renames columns in the list
+ * inserts columns in the list
+ * rewrites columns in the list (like transforming telephone numbers from local/national format to international format)
+ * writest the resulting data (that is a list with columns) to an excel file or to a comma separate values (CSV) file.
+
+How this is done is governed by a configuration file. The application can create a number of example configuration files with accompanying description text files.
+
+## Installing it
+
+If you want to use it install it using pip. A precondition is that you have Python 3.10.5 or newer installed on you computer. Python can be downloaded from [https://www.python.org/downloads/](https://www.python.org/downloads/).
+
+### Installing on mac and Linux
+
+````
+pip3 install excel-list-transform
+````
+
+### Installing on Microsoft Windows
+
+````
+pip install excel-list-transform
+````
+
+## Running the application
+
+### Running the application on mac and Linux
+
+````
+python3 -m excel_list_transform --help
+python3 -m excel_list_transform example --help
+python3 -m excel_list_transform transform --help
+python3 -m excel_list_transform example -k forms_to_rrs -r by_name -o example.cfg
+python3 -m excel_list_transform transform -c example.cfg -i input.xlsx -o output.xlsx
+````
+
+### Running the application on Microsoft Windows
+
+````
+python -m excel_list_transform --help
+python -m excel_list_transform example --help
+python -m excel_list_transform transform --help
+python -m excel_list_transform example -k forms_to_rrs -r by_name -o example.cfg
+python -m excel_list_transform transform -c example.cfg -i input.xlsx -o output.xlsx
+````
+
+## Suggested way to get started
+
+ 1. Use the "example" sub-command to generate a few example configuration (.cfg) files with description (.txt) files.
+ 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.
+
+### Description of configuration file
+
+When using the "example" sub-command to generate an example configuration file (say example.cfg) a text file describing the configuration and the syntax of the configuration file is also generated. If the example configuration file is named example.cfg, then the text file descriging the configuration is named example.txt. 
+
+You can generate several example configuration files each with an accompanying text file descriping it.
+
+Read the text file describing the configuration file while looking at the configuration file to understand the syntax and the possible options.
+
+## Performance
+
+This application is written for the moderate amounts of data when registering participants for the majority of sports events. If you have millions of rows this application is not for you.
+
+With an input file consisting of 20 columns producing an output file of 11 columns I have measured the following performance on a MacBook Air (laptop) from 2020:
+ * 1 000 rows processed in less than 0.5 seconds
+ * 10 000 rows processed in less than 4 seconds
+ * 80 000 rows processed in less than 30 seconds
+ * 120 000 rows processed in 40 seconds
+
+Naturally your performance will be different based on computer hardware, operating system and Python version. Generally it should be reasonably fast for less than 10 000 rows, painfully slow but somewhat usable up to 100 000 rows and probably so slow that it is unusable for more than 100 000 rows.
+
+## Source code
+
+Source code and tests are available at [https://bitbucket.org/tom-bjorkholm/excel-list-transform](https://bitbucket.org/tom-bjorkholm/excel-list-transform).